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