drivers/net/dm9000x.c

   1 /*
   2   dm9000.c: Version 1.2 12/15/2003
   3
   4         A Davicom DM9000 ISA NIC fast Ethernet driver for Linux.
   5         Copyright (C) 1997  Sten Wang
   6
   7         This program is free software; you can redistribute it and/or
   8         modify it under the terms of the GNU General Public License
   9         as published by the Free Software Foundation; either version 2
  10         of the License, or (at your option) any later version.
  11
  12         This program is distributed in the hope that it will be useful,
  13         but WITHOUT ANY WARRANTY; without even the implied warranty of
  14         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15         GNU General Public License for more details.
  16
  17   (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
  18
  19 V0.11   06/20/2001      REG_0A bit3=1, default enable BP with DA match
  20         06/22/2001      Support DM9801 progrmming
  21                         E3: R25 = ((R24 + NF) & 0x00ff) | 0xf000
  22                         E4: R25 = ((R24 + NF) & 0x00ff) | 0xc200
  23                 R17 = (R17 & 0xfff0) | NF + 3
  24                         E5: R25 = ((R24 + NF - 3) & 0x00ff) | 0xc200
  25                 R17 = (R17 & 0xfff0) | NF
  26
  27 v1.00                   modify by simon 2001.9.5
  28                         change for kernel 2.4.x
  29
  30 v1.1   11/09/2001       fix force mode bug
  31
  32 v1.2   03/18/2003       Weilun Huang <weilun_huang@davicom.com.tw>:
  33                         Fixed phy reset.
  34                         Added tx/rx 32 bit mode.
  35                         Cleaned up for kernel merge.
  36
  37 --------------------------------------
  38
  39        12/15/2003       Initial port to u-boot by
  40                         Sascha Hauer <saschahauer@web.de>
  41
  42        06/03/2008       Remy Bohmer <linux@bohmer.net>
  43                         - Added autodetect of databus width.
  44                         - Made debug code compile again.
  45                         - Adapt eth_send such that it matches the DM9000*
  46                           application notes. Needed to make it work properly
  47                           for DM9000A.
  48                         - Adapted reset procedure to match DM9000 application
  49                           notes (i.e. double reset)
  50                         These changes are tested with DM9000{A,EP,E} together
  51                         with a 200MHz Atmel AT91SAM92161 core
  52
  53 TODO: Homerun NIC and longrun NIC are not functional, only internal at the
  54       moment.
  55 */
  56
  57 #include <common.h>
  58 #include <command.h>
  59 #include <net.h>
  60 #include <asm/io.h>
  61
  62 #ifdef CONFIG_DRIVER_DM9000
  63
  64 #include "dm9000x.h"
  65
  66 /* Board/System/Debug information/definition ---------------- */
  67
  68 #define DM9801_NOISE_FLOOR      0x08
  69 #define DM9802_NOISE_FLOOR      0x05
  70
  71 /* #define CONFIG_DM9000_DEBUG */
  72
  73 #ifdef CONFIG_DM9000_DEBUG
  74 #define DM9000_DBG(fmt,args...) printf(fmt, ##args)
  75 #define DM9000_DMP_PACKET(func,packet,length)  \
  76         do { \
  77                 int i;                                                  \
  78                 printf(func ": length: %d\n", length);                  \
  79                 for (i = 0; i < length; i++) {                          \
  80                         if (i % 8 == 0)                                 \
  81                                 printf("\n%s: %02x: ", func, i);        \
  82                         printf("%02x ", ((unsigned char *) packet)[i]); \
  83                 } printf("\n");                                         \
  84         } while(0)
  85 #else
  86 #define DM9000_DBG(fmt,args...)
  87 #define DM9000_DMP_PACKET(func,packet,length)
  88 #endif
  89
  90 enum DM9000_PHY_mode { DM9000_10MHD = 0, DM9000_100MHD =
  91             1, DM9000_10MFD = 4, DM9000_100MFD = 5, DM9000_AUTO =
  92             8, DM9000_1M_HPNA = 0x10
  93 };
  94 enum DM9000_NIC_TYPE { FASTETHER_NIC = 0, HOMERUN_NIC = 1, LONGRUN_NIC = 2
  95 };
  96
  97 /* Structure/enum declaration ------------------------------- */
  98 typedef struct board_info {
  99         u32 runt_length_counter;        /* counter: RX length < 64byte */
 100         u32 long_length_counter;        /* counter: RX length > 1514byte */
 101         u32 reset_counter;      /* counter: RESET */
 102         u32 reset_tx_timeout;   /* RESET caused by TX Timeout */
 103         u32 reset_rx_status;    /* RESET caused by RX Statsus wrong */
 104         u16 tx_pkt_cnt;
 105         u16 queue_start_addr;
 106         u16 dbug_cnt;
 107         u8 phy_addr;
 108         u8 device_wait_reset;   /* device state */
 109         u8 nic_type;            /* NIC type */
 110         unsigned char srom[128];
 111         void (*outblk)(void *data_ptr, int count);
 112         void (*inblk)(void *data_ptr, int count);
 113         void (*rx_status)(u16 *RxStatus, u16 *RxLen);
 114  } board_info_t;
 115 static board_info_t dm9000_info;
 116
 117 /* For module input parameter */
 118 static int media_mode = DM9000_AUTO;
 119 static u8 nfloor = 0;
 120
 121 /* function declaration ------------------------------------- */
 122 int eth_init(bd_t * bd);
 123 int eth_send(volatile void *, int);
 124 int eth_rx(void);
 125 void eth_halt(void);
 126 static int dm9000_probe(void);
 127 static u16 phy_read(int);
 128 static void phy_write(int, u16);
 129 u16 read_srom_word(int);
 130 static u8 DM9000_ior(int);
 131 static void DM9000_iow(int reg, u8 value);
 132
 133 /* DM9000 network board routine ---------------------------- */
 134
 135 #define DM9000_outb(d,r) ( *(volatile u8 *)r = d )
 136 #define DM9000_outw(d,r) ( *(volatile u16 *)r = d )
 137 #define DM9000_outl(d,r) ( *(volatile u32 *)r = d )
 138 #define DM9000_inb(r) (*(volatile u8 *)r)
 139 #define DM9000_inw(r) (*(volatile u16 *)r)
 140 #define DM9000_inl(r) (*(volatile u32 *)r)
 141
 142 #ifdef CONFIG_DM9000_DEBUG
 143 static void
 144 dump_regs(void)
 145 {
 146         DM9000_DBG("\n");
 147         DM9000_DBG("NCR   (0x00): %02x\n", DM9000_ior(0));
 148         DM9000_DBG("NSR   (0x01): %02x\n", DM9000_ior(1));
 149         DM9000_DBG("TCR   (0x02): %02x\n", DM9000_ior(2));
 150         DM9000_DBG("TSRI  (0x03): %02x\n", DM9000_ior(3));
 151         DM9000_DBG("TSRII (0x04): %02x\n", DM9000_ior(4));
 152         DM9000_DBG("RCR   (0x05): %02x\n", DM9000_ior(5));
 153         DM9000_DBG("RSR   (0x06): %02x\n", DM9000_ior(6));
 154         DM9000_DBG("ISR   (0xFE): %02x\n", DM9000_ior(DM9000_ISR));
 155         DM9000_DBG("\n");
 156 }
 157 #endif
 158
 159 static void dm9000_outblk_8bit(void *data_ptr, int count)
 160 {
 161         int i;
 162         for (i = 0; i < count; i++)
 163                 DM9000_outb((((u8 *) data_ptr)[i] & 0xff), DM9000_DATA);
 164 }
 165
 166 static void dm9000_outblk_16bit(void *data_ptr, int count)
 167 {
 168         int i;
 169         u32 tmplen = (count + 1) / 2;
 170
 171         for (i = 0; i < tmplen; i++)
 172                 DM9000_outw(((u16 *) data_ptr)[i], DM9000_DATA);
 173 }
 174 static void dm9000_outblk_32bit(void *data_ptr, int count)
 175 {
 176         int i;
 177         u32 tmplen = (count + 3) / 4;
 178
 179         for (i = 0; i < tmplen; i++)
 180                 DM9000_outl(((u32 *) data_ptr)[i], DM9000_DATA);
 181 }
 182
 183 static void dm9000_inblk_8bit(void *data_ptr, int count)
 184 {
 185         int i;
 186         for (i = 0; i < count; i++)
 187                 ((u8 *) data_ptr)[i] = DM9000_inb(DM9000_DATA);
 188 }
 189
 190 static void dm9000_inblk_16bit(void *data_ptr, int count)
 191 {
 192         int i;
 193         u32 tmplen = (count + 1) / 2;
 194
 195         for (i = 0; i < tmplen; i++)
 196                 ((u16 *) data_ptr)[i] = DM9000_inw(DM9000_DATA);
 197 }
 198 static void dm9000_inblk_32bit(void *data_ptr, int count)
 199 {
 200         int i;
 201         u32 tmplen = (count + 3) / 4;
 202
 203         for (i = 0; i < tmplen; i++)
 204                 ((u32 *) data_ptr)[i] = DM9000_inl(DM9000_DATA);
 205 }
 206
 207 static void dm9000_rx_status_32bit(u16 *RxStatus, u16 *RxLen)
 208 {
 209         u32 tmpdata = DM9000_inl(DM9000_DATA);
 210
 211         DM9000_outb(DM9000_MRCMD, DM9000_IO);
 212
 213         *RxStatus = tmpdata;
 214         *RxLen = tmpdata >> 16;
 215 }
 216
 217 static void dm9000_rx_status_16bit(u16 *RxStatus, u16 *RxLen)
 218 {
 219         DM9000_outb(DM9000_MRCMD, DM9000_IO);
 220
 221         *RxStatus = DM9000_inw(DM9000_DATA);
 222         *RxLen = DM9000_inw(DM9000_DATA);
 223 }
 224
 225 static void dm9000_rx_status_8bit(u16 *RxStatus, u16 *RxLen)
 226 {
 227         DM9000_outb(DM9000_MRCMD, DM9000_IO);
 228
 229         *RxStatus = DM9000_inb(DM9000_DATA) + (DM9000_inb(DM9000_DATA) << 8);
 230         *RxLen = DM9000_inb(DM9000_DATA) + (DM9000_inb(DM9000_DATA) << 8);
 231 }
 232
 233 /*
 234   Search DM9000 board, allocate space and register it
 235 */
 236 int
 237 dm9000_probe(void)
 238 {
 239         u32 id_val;
 240         id_val = DM9000_ior(DM9000_VIDL);
 241         id_val |= DM9000_ior(DM9000_VIDH) << 8;
 242         id_val |= DM9000_ior(DM9000_PIDL) << 16;
 243         id_val |= DM9000_ior(DM9000_PIDH) << 24;
 244         if (id_val == DM9000_ID) {
 245                 printf("dm9000 i/o: 0x%x, id: 0x%x \n", CONFIG_DM9000_BASE,
 246                        id_val);
 247                 return 0;
 248         } else {
 249                 printf("dm9000 not found at 0x%08x id: 0x%08x\n",
 250                        CONFIG_DM9000_BASE, id_val);
 251                 return -1;
 252         }
 253 }
 254
 255 /* Set PHY operationg mode
 256 */
 257 static void
 258 set_PHY_mode(void)
 259 {
 260         u16 phy_reg4 = 0x01e1, phy_reg0 = 0x1000;
 261         if (!(media_mode & DM9000_AUTO)) {
 262                 switch (media_mode) {
 263                 case DM9000_10MHD:
 264                         phy_reg4 = 0x21;
 265                         phy_reg0 = 0x0000;
 266                         break;
 267                 case DM9000_10MFD:
 268                         phy_reg4 = 0x41;
 269                         phy_reg0 = 0x1100;
 270                         break;
 271                 case DM9000_100MHD:
 272                         phy_reg4 = 0x81;
 273                         phy_reg0 = 0x2000;
 274                         break;
 275                 case DM9000_100MFD:
 276                         phy_reg4 = 0x101;
 277                         phy_reg0 = 0x3100;
 278                         break;
 279                 }
 280                 phy_write(4, phy_reg4); /* Set PHY media mode */
 281                 phy_write(0, phy_reg0); /*  Tmp */
 282         }
 283         DM9000_iow(DM9000_GPCR, 0x01);  /* Let GPIO0 output */
 284         DM9000_iow(DM9000_GPR, 0x00);   /* Enable PHY */
 285 }
 286
 287 /*
 288         Init HomeRun DM9801
 289 */
 290 static void
 291 program_dm9801(u16 HPNA_rev)
 292 {
 293         __u16 reg16, reg17, reg24, reg25;
 294         if (!nfloor)
 295                 nfloor = DM9801_NOISE_FLOOR;
 296         reg16 = phy_read(16);
 297         reg17 = phy_read(17);
 298         reg24 = phy_read(24);
 299         reg25 = phy_read(25);
 300         switch (HPNA_rev) {
 301         case 0xb900:            /* DM9801 E3 */
 302                 reg16 |= 0x1000;
 303                 reg25 = ((reg24 + nfloor) & 0x00ff) | 0xf000;
 304                 break;
 305         case 0xb901:            /* DM9801 E4 */
 306                 reg25 = ((reg24 + nfloor) & 0x00ff) | 0xc200;
 307                 reg17 = (reg17 & 0xfff0) + nfloor + 3;
 308                 break;
 309         case 0xb902:            /* DM9801 E5 */
 310         case 0xb903:            /* DM9801 E6 */
 311         default:
 312                 reg16 |= 0x1000;
 313                 reg25 = ((reg24 + nfloor - 3) & 0x00ff) | 0xc200;
 314                 reg17 = (reg17 & 0xfff0) + nfloor;
 315         }
 316         phy_write(16, reg16);
 317         phy_write(17, reg17);
 318         phy_write(25, reg25);
 319 }
 320
 321 /*
 322         Init LongRun DM9802
 323 */
 324 static void
 325 program_dm9802(void)
 326 {
 327         __u16 reg25;
 328         if (!nfloor)
 329                 nfloor = DM9802_NOISE_FLOOR;
 330         reg25 = phy_read(25);
 331         reg25 = (reg25 & 0xff00) + nfloor;
 332         phy_write(25, reg25);
 333 }
 334
 335 /* Identify NIC type
 336 */
 337 static void
 338 identify_nic(void)
 339 {
 340         struct board_info *db = &dm9000_info;
 341         u16 phy_reg3;
 342         DM9000_iow(DM9000_NCR, NCR_EXT_PHY);
 343         phy_reg3 = phy_read(3);
 344         switch (phy_reg3 & 0xfff0) {
 345         case 0xb900:
 346                 if (phy_read(31) == 0x4404) {
 347                         db->nic_type = HOMERUN_NIC;
 348                         program_dm9801(phy_reg3);
 349                         DM9000_DBG("found homerun NIC\n");
 350                 } else {
 351                         db->nic_type = LONGRUN_NIC;
 352                         DM9000_DBG("found longrun NIC\n");
 353                         program_dm9802();
 354                 }
 355                 break;
 356         default:
 357                 db->nic_type = FASTETHER_NIC;
 358                 break;
 359         }
 360         DM9000_iow(DM9000_NCR, 0);
 361 }
 362
 363 /* General Purpose dm9000 reset routine */
 364 static void
 365 dm9000_reset(void)
 366 {
 367         DM9000_DBG("resetting DM9000\n");
 368
 369         /* Reset DM9000,
 370            see DM9000 Application Notes V1.22 Jun 11, 2004 page 29 */
 371
 372         /* DEBUG: Make all GPIO pins outputs */
 373         DM9000_iow(DM9000_GPCR, 0x0F);
 374         /* Step 1: Power internal PHY by writing 0 to GPIO0 pin */
 375         DM9000_iow(DM9000_GPR, 0);
 376         /* Step 2: Software reset */
 377         DM9000_iow(DM9000_NCR, 3);
 378
 379         do {
 380                 DM9000_DBG("resetting the DM9000, 1st reset\n");
 381                 udelay(25); /* Wait at least 20 us */
 382         } while (DM9000_ior(DM9000_NCR) & 1);
 383
 384         DM9000_iow(DM9000_NCR, 0);
 385         DM9000_iow(DM9000_NCR, 3); /* Issue a second reset */
 386
 387         do {
 388                 DM9000_DBG("resetting the DM9000, 2nd reset\n");
 389                 udelay(25); /* Wait at least 20 us */
 390         } while (DM9000_ior(DM9000_NCR) & 1);
 391
 392         /* Check whether the ethernet controller is present */
 393         if ((DM9000_ior(DM9000_PIDL) != 0x0) ||
 394             (DM9000_ior(DM9000_PIDH) != 0x90))
 395                 printf("ERROR: resetting DM9000 -> not responding\n");
 396 }
 397
 398 /* Initilize dm9000 board
 399 */
 400 int
 401 eth_init(bd_t * bd)
 402 {
 403         int i, oft, lnk;
 404         u8 io_mode;
 405         struct board_info *db = &dm9000_info;
 406
 407         DM9000_DBG("eth_init()\n");
 408
 409         /* RESET device */
 410         dm9000_reset();
 411         dm9000_probe();
 412
 413         /* Auto-detect 8/16/32 bit mode, ISR Bit 6+7 indicate bus width */
 414         io_mode = DM9000_ior(DM9000_ISR) >> 6;
 415
 416         switch (io_mode) {
 417         case 0x0:  /* 16-bit mode */
 418                 printf("DM9000: running in 16 bit mode\n");
 419                 db->outblk    = dm9000_outblk_16bit;
 420                 db->inblk     = dm9000_inblk_16bit;
 421                 db->rx_status = dm9000_rx_status_16bit;
 422                 break;
 423         case 0x01:  /* 32-bit mode */
 424                 printf("DM9000: running in 32 bit mode\n");
 425                 db->outblk    = dm9000_outblk_32bit;
 426                 db->inblk     = dm9000_inblk_32bit;
 427                 db->rx_status = dm9000_rx_status_32bit;
 428                 break;
 429         case 0x02: /* 8 bit mode */
 430                 printf("DM9000: running in 8 bit mode\n");
 431                 db->outblk    = dm9000_outblk_8bit;
 432                 db->inblk     = dm9000_inblk_8bit;
 433                 db->rx_status = dm9000_rx_status_8bit;
 434                 break;
 435         default:
 436                 /* Assume 8 bit mode, will probably not work anyway */
 437                 printf("DM9000: Undefined IO-mode:0x%x\n", io_mode);
 438                 db->outblk    = dm9000_outblk_8bit;
 439                 db->inblk     = dm9000_inblk_8bit;
 440                 db->rx_status = dm9000_rx_status_8bit;
 441                 break;
 442         }
 443
 444         /* NIC Type: FASTETHER, HOMERUN, LONGRUN */
 445         identify_nic();
 446
 447         /* GPIO0 on pre-activate PHY */
 448         DM9000_iow(DM9000_GPR, 0x00);   /*REG_1F bit0 activate phyxcer */
 449
 450         /* Set PHY */
 451         set_PHY_mode();
 452
 453         /* Program operating register */
 454         DM9000_iow(DM9000_NCR, 0x0);    /* only intern phy supported by now */
 455         DM9000_iow(DM9000_TCR, 0);      /* TX Polling clear */
 456         DM9000_iow(DM9000_BPTR, 0x3f);  /* Less 3Kb, 200us */
 457         DM9000_iow(DM9000_FCTR, FCTR_HWOT(3) | FCTR_LWOT(8));   /* Flow Control : High/Low Water */
 458         DM9000_iow(DM9000_FCR, 0x0);    /* SH FIXME: This looks strange! Flow Control */
 459         DM9000_iow(DM9000_SMCR, 0);     /* Special Mode */
 460         DM9000_iow(DM9000_NSR, NSR_WAKEST | NSR_TX2END | NSR_TX1END);   /* clear TX status */
 461         DM9000_iow(DM9000_ISR, 0x0f);   /* Clear interrupt status */
 462
 463         /* Set Node address */
 464         for (i = 0; i < 6; i++)
 465                 ((u16 *) bd->bi_enetaddr)[i] = read_srom_word(i);
 466
 467         if (is_zero_ether_addr(bd->bi_enetaddr) ||
 468             is_multicast_ether_addr(bd->bi_enetaddr)) {
 469                 /* try reading from environment */
 470                 u8 i;
 471                 char *s, *e;
 472                 s = getenv ("ethaddr");
 473                 for (i = 0; i < 6; ++i) {
 474                         bd->bi_enetaddr[i] = s ?
 475                                 simple_strtoul (s, &e, 16) : 0;
 476                         if (s)
 477                                 s = (*e) ? e + 1 : e;
 478                 }
 479         }
 480
 481         printf("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", bd->bi_enetaddr[0],
 482                bd->bi_enetaddr[1], bd->bi_enetaddr[2], bd->bi_enetaddr[3],
 483                bd->bi_enetaddr[4], bd->bi_enetaddr[5]);
 484         for (i = 0, oft = 0x10; i < 6; i++, oft++)
 485                 DM9000_iow(oft, bd->bi_enetaddr[i]);
 486         for (i = 0, oft = 0x16; i < 8; i++, oft++)
 487                 DM9000_iow(oft, 0xff);
 488
 489         /* read back mac, just to be sure */
 490         for (i = 0, oft = 0x10; i < 6; i++, oft++)
 491                 DM9000_DBG("%02x:", DM9000_ior(oft));
 492         DM9000_DBG("\n");
 493
 494         /* Activate DM9000 */
 495         DM9000_iow(DM9000_RCR, RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN);  /* RX enable */
 496         DM9000_iow(DM9000_IMR, IMR_PAR);        /* Enable TX/RX interrupt mask */
 497         i = 0;
 498         while (!(phy_read(1) & 0x20)) { /* autonegation complete bit */
 499                 udelay(1000);
 500                 i++;
 501                 if (i == 10000) {
 502                         printf("could not establish link\n");
 503                         return 0;
 504                 }
 505         }
 506
 507         /* see what we've got */
 508         lnk = phy_read(17) >> 12;
 509         printf("operating at ");
 510         switch (lnk) {
 511         case 1:
 512                 printf("10M half duplex ");
 513                 break;
 514         case 2:
 515                 printf("10M full duplex ");
 516                 break;
 517         case 4:
 518                 printf("100M half duplex ");
 519                 break;
 520         case 8:
 521                 printf("100M full duplex ");
 522                 break;
 523         default:
 524                 printf("unknown: %d ", lnk);
 525                 break;
 526         }
 527         printf("mode\n");
 528         return 0;
 529 }
 530
 531 /*
 532   Hardware start transmission.
 533   Send a packet to media from the upper layer.
 534 */
 535 int
 536 eth_send(volatile void *packet, int length)
 537 {
 538         char *data_ptr;
 539         int tmo;
 540         struct board_info *db = &dm9000_info;
 541
 542         DM9000_DMP_PACKET("eth_send", packet, length);
 543
 544         DM9000_iow(DM9000_ISR, IMR_PTM); /* Clear Tx bit in ISR */
 545
 546         /* Move data to DM9000 TX RAM */
 547         data_ptr = (char *) packet;
 548         DM9000_outb(DM9000_MWCMD, DM9000_IO); /* Prepare for TX-data */
 549
 550         /* push the data to the TX-fifo */
 551         (db->outblk)(data_ptr, length);
 552
 553         /* Set TX length to DM9000 */
 554         DM9000_iow(DM9000_TXPLL, length & 0xff);
 555         DM9000_iow(DM9000_TXPLH, (length >> 8) & 0xff);
 556
 557         /* Issue TX polling command */
 558         DM9000_iow(DM9000_TCR, TCR_TXREQ); /* Cleared after TX complete */
 559
 560         /* wait for end of transmission */
 561         tmo = get_timer(0) + 5 * CFG_HZ;
 562         while ( !(DM9000_ior(DM9000_NSR) & (NSR_TX1END | NSR_TX2END)) ||
 563                 !(DM9000_ior(DM9000_ISR) & IMR_PTM) ) {
 564                 if (get_timer(0) >= tmo) {
 565                         printf("transmission timeout\n");
 566                         break;
 567                 }
 568         }
 569         DM9000_iow(DM9000_ISR, IMR_PTM); /* Clear Tx bit in ISR */
 570
 571         DM9000_DBG("transmit done\n\n");
 572         return 0;
 573 }
 574
 575 /*
 576   Stop the interface.
 577   The interface is stopped when it is brought.
 578 */
 579 void
 580 eth_halt(void)
 581 {
 582         DM9000_DBG("eth_halt\n");
 583
 584         /* RESET devie */
 585         phy_write(0, 0x8000);   /* PHY RESET */
 586         DM9000_iow(DM9000_GPR, 0x01);   /* Power-Down PHY */
 587         DM9000_iow(DM9000_IMR, 0x80);   /* Disable all interrupt */
 588         DM9000_iow(DM9000_RCR, 0x00);   /* Disable RX */
 589 }
 590
 591 /*
 592   Received a packet and pass to upper layer
 593 */
 594 int
 595 eth_rx(void)
 596 {
 597         u8 rxbyte, *rdptr = (u8 *) NetRxPackets[0];
 598         u16 RxStatus, RxLen = 0;
 599         struct board_info *db = &dm9000_info;
 600
 601         /* Check packet ready or not */
 602         DM9000_ior(DM9000_MRCMDX);      /* Dummy read */
 603         rxbyte = DM9000_inb(DM9000_DATA);       /* Got most updated data */
 604         if (rxbyte == 0)
 605                 return 0;
 606
 607         /* Status check: this byte must be 0 or 1 */
 608         if (rxbyte > 1) {
 609                 DM9000_iow(DM9000_RCR, 0x00);   /* Stop Device */
 610                 DM9000_iow(DM9000_ISR, 0x80);   /* Stop INT request */
 611                 DM9000_DBG("rx status check: %d\n", rxbyte);
 612         }
 613         DM9000_DBG("receiving packet\n");
 614
 615         /* A packet ready now  & Get status/length */
 616         DM9000_outb(DM9000_MRCMD, DM9000_IO);
 617
 618         (db->rx_status)(&RxStatus, &RxLen);
 619
 620         DM9000_DBG("rx status: 0x%04x rx len: %d\n", RxStatus, RxLen);
 621
 622         /* Move data from DM9000 */
 623         /* Read received packet from RX SRAM */
 624         (db->inblk)(rdptr, RxLen);
 625
 626         if ((RxStatus & 0xbf00) || (RxLen < 0x40)
 627             || (RxLen > DM9000_PKT_MAX)) {
 628                 if (RxStatus & 0x100) {
 629                         printf("rx fifo error\n");
 630                 }
 631                 if (RxStatus & 0x200) {
 632                         printf("rx crc error\n");
 633                 }
 634                 if (RxStatus & 0x8000) {
 635                         printf("rx length error\n");
 636                 }
 637                 if (RxLen > DM9000_PKT_MAX) {
 638                         printf("rx length too big\n");
 639                         dm9000_reset();
 640                 }
 641         } else {
 642                 DM9000_DMP_PACKET("eth_rx", rdptr, RxLen);
 643
 644                 /* Pass to upper layer */
 645                 DM9000_DBG("passing packet to upper layer\n");
 646                 NetReceive(NetRxPackets[0], RxLen);
 647                 return RxLen;
 648         }
 649         return 0;
 650 }
 651
 652 /*
 653   Read a word data from SROM
 654 */
 655 u16
 656 read_srom_word(int offset)
 657 {
 658         DM9000_iow(DM9000_EPAR, offset);
 659         DM9000_iow(DM9000_EPCR, 0x4);
 660         udelay(8000);
 661         DM9000_iow(DM9000_EPCR, 0x0);
 662         return (DM9000_ior(DM9000_EPDRL) + (DM9000_ior(DM9000_EPDRH) << 8));
 663 }
 664
 665 void
 666 write_srom_word(int offset, u16 val)
 667 {
 668         DM9000_iow(DM9000_EPAR, offset);
 669         DM9000_iow(DM9000_EPDRH, ((val >> 8) & 0xff));
 670         DM9000_iow(DM9000_EPDRL, (val & 0xff));
 671         DM9000_iow(DM9000_EPCR, 0x12);
 672         udelay(8000);
 673         DM9000_iow(DM9000_EPCR, 0);
 674 }
 675
 676
 677 /*
 678    Read a byte from I/O port
 679 */
 680 static u8
 681 DM9000_ior(int reg)
 682 {
 683         DM9000_outb(reg, DM9000_IO);
 684         return DM9000_inb(DM9000_DATA);
 685 }
 686
 687 /*
 688    Write a byte to I/O port
 689 */
 690 static void
 691 DM9000_iow(int reg, u8 value)
 692 {
 693         DM9000_outb(reg, DM9000_IO);
 694         DM9000_outb(value, DM9000_DATA);
 695 }
 696
 697 /*
 698    Read a word from phyxcer
 699 */
 700 static u16
 701 phy_read(int reg)
 702 {
 703         u16 val;
 704
 705         /* Fill the phyxcer register into REG_0C */
 706         DM9000_iow(DM9000_EPAR, DM9000_PHY | reg);
 707         DM9000_iow(DM9000_EPCR, 0xc);   /* Issue phyxcer read command */
 708         udelay(100);            /* Wait read complete */
 709         DM9000_iow(DM9000_EPCR, 0x0);   /* Clear phyxcer read command */
 710         val = (DM9000_ior(DM9000_EPDRH) << 8) | DM9000_ior(DM9000_EPDRL);
 711
 712         /* The read data keeps on REG_0D & REG_0E */
 713         DM9000_DBG("phy_read(0x%x): 0x%x\n", reg, val);
 714         return val;
 715 }
 716
 717 /*
 718    Write a word to phyxcer
 719 */
 720 static void
 721 phy_write(int reg, u16 value)
 722 {
 723
 724         /* Fill the phyxcer register into REG_0C */
 725         DM9000_iow(DM9000_EPAR, DM9000_PHY | reg);
 726
 727         /* Fill the written data into REG_0D & REG_0E */
 728         DM9000_iow(DM9000_EPDRL, (value & 0xff));
 729         DM9000_iow(DM9000_EPDRH, ((value >> 8) & 0xff));
 730         DM9000_iow(DM9000_EPCR, 0xa);   /* Issue phyxcer write command */
 731         udelay(500);            /* Wait write complete */
 732         DM9000_iow(DM9000_EPCR, 0x0);   /* Clear phyxcer write command */
 733         DM9000_DBG("phy_write(reg:0x%x, value:0x%x)\n", reg, value);
 734 }
 735 #endif                          /* CONFIG_DRIVER_DM9000 */