drivers/net/ns8382x.c

   1 /*
   2    ns8382x.c: A U-Boot driver for the NatSemi DP8382[01].
   3    ported by: Mark A. Rakes (mark_rakes@vivato.net)
   4
   5    Adapted from:
   6    1. an Etherboot driver for DP8381[56] written by:
   7            Copyright (C) 2001 Entity Cyber, Inc.
   8
   9            This development of this Etherboot driver was funded by
  10                   Sicom Systems: http://www.sicompos.com/
  11
  12            Author: Marty Connor (mdc@thinguin.org)
  13            Adapted from a Linux driver which was written by Donald Becker
  14
  15            This software may be used and distributed according to the terms
  16            of the GNU Public License (GPL), incorporated herein by reference.
  17
  18    2. A Linux driver by Donald Becker, ns820.c:
  19                 Written/copyright 1999-2002 by Donald Becker.
  20
  21                 This software may be used and distributed according to the terms of
  22                 the GNU General Public License (GPL), incorporated herein by reference.
  23                 Drivers based on or derived from this code fall under the GPL and must
  24                 retain the authorship, copyright and license notice.  This file is not
  25                 a complete program and may only be used when the entire operating
  26                 system is licensed under the GPL.  License for under other terms may be
  27                 available.  Contact the original author for details.
  28
  29                 The original author may be reached as becker@scyld.com, or at
  30                 Scyld Computing Corporation
  31                 410 Severn Ave., Suite 210
  32                 Annapolis MD 21403
  33
  34                 Support information and updates available at
  35                 http://www.scyld.com/network/netsemi.html
  36
  37    Datasheets available from:
  38    http://www.national.com/pf/DP/DP83820.html
  39    http://www.national.com/pf/DP/DP83821.html
  40 */
  41
  42 /* Revision History
  43  * October 2002 mar     1.0
  44  *   Initial U-Boot Release.
  45  *      Tested with Netgear GA622T (83820)
  46  *      and SMC9452TX (83821)
  47  *      NOTE: custom boards with these chips may (likely) require
  48  *      a programmed EEPROM device (if present) in order to work
  49  *      correctly.
  50 */
  51
  52 /* Includes */
  53 #include <common.h>
  54 #include <malloc.h>
  55 #include <net.h>
  56 #include <asm/io.h>
  57 #include <pci.h>
  58
  59 /* defines */
  60 #define DSIZE     0x00000FFF
  61 #define ETH_ALEN                6
  62 #define CRC_SIZE  4
  63 #define TOUT_LOOP   500000
  64 #define TX_BUF_SIZE    1536
  65 #define RX_BUF_SIZE    1536
  66 #define NUM_RX_DESC    4        /* Number of Rx descriptor registers. */
  67
  68 enum register_offsets {
  69         ChipCmd = 0x00,
  70         ChipConfig = 0x04,
  71         EECtrl = 0x08,
  72         IntrMask = 0x14,
  73         IntrEnable = 0x18,
  74         TxRingPtr = 0x20,
  75         TxRingPtrHi = 0x24,
  76         TxConfig = 0x28,
  77         RxRingPtr = 0x30,
  78         RxRingPtrHi = 0x34,
  79         RxConfig = 0x38,
  80         PriQueue = 0x3C,
  81         RxFilterAddr = 0x48,
  82         RxFilterData = 0x4C,
  83         ClkRun = 0xCC,
  84         PCIPM = 0x44,
  85 };
  86
  87 enum ChipCmdBits {
  88         ChipReset = 0x100,
  89         RxReset = 0x20,
  90         TxReset = 0x10,
  91         RxOff = 0x08,
  92         RxOn = 0x04,
  93         TxOff = 0x02,
  94         TxOn = 0x01
  95 };
  96
  97 enum ChipConfigBits {
  98         LinkSts = 0x80000000,
  99         GigSpeed = 0x40000000,
 100         HundSpeed = 0x20000000,
 101         FullDuplex = 0x10000000,
 102         TBIEn = 0x01000000,
 103         Mode1000 = 0x00400000,
 104         T64En = 0x00004000,
 105         D64En = 0x00001000,
 106         M64En = 0x00000800,
 107         PhyRst = 0x00000400,
 108         PhyDis = 0x00000200,
 109         ExtStEn = 0x00000100,
 110         BEMode = 0x00000001,
 111 };
 112 #define SpeedStatus_Polarity ( GigSpeed | HundSpeed | FullDuplex)
 113
 114 enum TxConfig_bits {
 115         TxDrthMask      = 0x000000ff,
 116         TxFlthMask      = 0x0000ff00,
 117         TxMxdmaMask     = 0x00700000,
 118         TxMxdma_8       = 0x00100000,
 119         TxMxdma_16      = 0x00200000,
 120         TxMxdma_32      = 0x00300000,
 121         TxMxdma_64      = 0x00400000,
 122         TxMxdma_128     = 0x00500000,
 123         TxMxdma_256     = 0x00600000,
 124         TxMxdma_512     = 0x00700000,
 125         TxMxdma_1024    = 0x00000000,
 126         TxCollRetry     = 0x00800000,
 127         TxAutoPad       = 0x10000000,
 128         TxMacLoop       = 0x20000000,
 129         TxHeartIgn      = 0x40000000,
 130         TxCarrierIgn    = 0x80000000
 131 };
 132
 133 enum RxConfig_bits {
 134         RxDrthMask      = 0x0000003e,
 135         RxMxdmaMask     = 0x00700000,
 136         RxMxdma_8       = 0x00100000,
 137         RxMxdma_16      = 0x00200000,
 138         RxMxdma_32      = 0x00300000,
 139         RxMxdma_64      = 0x00400000,
 140         RxMxdma_128     = 0x00500000,
 141         RxMxdma_256     = 0x00600000,
 142         RxMxdma_512     = 0x00700000,
 143         RxMxdma_1024    = 0x00000000,
 144         RxAcceptLenErr  = 0x04000000,
 145         RxAcceptLong    = 0x08000000,
 146         RxAcceptTx      = 0x10000000,
 147         RxStripCRC      = 0x20000000,
 148         RxAcceptRunt    = 0x40000000,
 149         RxAcceptErr     = 0x80000000,
 150 };
 151
 152 /* Bits in the RxMode register. */
 153 enum rx_mode_bits {
 154         RxFilterEnable          = 0x80000000,
 155         AcceptAllBroadcast      = 0x40000000,
 156         AcceptAllMulticast      = 0x20000000,
 157         AcceptAllUnicast        = 0x10000000,
 158         AcceptPerfectMatch      = 0x08000000,
 159 };
 160
 161 typedef struct _BufferDesc {
 162         u32 link;
 163         u32 bufptr;
 164         vu_long cmdsts;
 165         u32 extsts;             /*not used here */
 166 } BufferDesc;
 167
 168 /* Bits in network_desc.status */
 169 enum desc_status_bits {
 170         DescOwn = 0x80000000, DescMore = 0x40000000, DescIntr = 0x20000000,
 171         DescNoCRC = 0x10000000, DescPktOK = 0x08000000,
 172         DescSizeMask = 0xfff,
 173
 174         DescTxAbort = 0x04000000, DescTxFIFO = 0x02000000,
 175         DescTxCarrier = 0x01000000, DescTxDefer = 0x00800000,
 176         DescTxExcDefer = 0x00400000, DescTxOOWCol = 0x00200000,
 177         DescTxExcColl = 0x00100000, DescTxCollCount = 0x000f0000,
 178
 179         DescRxAbort = 0x04000000, DescRxOver = 0x02000000,
 180         DescRxDest = 0x01800000, DescRxLong = 0x00400000,
 181         DescRxRunt = 0x00200000, DescRxInvalid = 0x00100000,
 182         DescRxCRC = 0x00080000, DescRxAlign = 0x00040000,
 183         DescRxLoop = 0x00020000, DesRxColl = 0x00010000,
 184 };
 185
 186 /* Bits in MEAR */
 187 enum mii_reg_bits {
 188         MDIO_ShiftClk = 0x0040,
 189         MDIO_EnbOutput = 0x0020,
 190         MDIO_Data = 0x0010,
 191 };
 192
 193 /* PHY Register offsets.  */
 194 enum phy_reg_offsets {
 195         BMCR = 0x00,
 196         BMSR = 0x01,
 197         PHYIDR1 = 0x02,
 198         PHYIDR2 = 0x03,
 199         ANAR = 0x04,
 200         KTCR = 0x09,
 201 };
 202
 203 /* basic mode control register bits */
 204 enum bmcr_bits {
 205         Bmcr_Reset = 0x8000,
 206         Bmcr_Loop = 0x4000,
 207         Bmcr_Speed0 = 0x2000,
 208         Bmcr_AutoNegEn = 0x1000,        /*if set ignores Duplex, Speed[01] */
 209         Bmcr_RstAutoNeg = 0x0200,
 210         Bmcr_Duplex = 0x0100,
 211         Bmcr_Speed1 = 0x0040,
 212         Bmcr_Force10H = 0x0000,
 213         Bmcr_Force10F = 0x0100,
 214         Bmcr_Force100H = 0x2000,
 215         Bmcr_Force100F = 0x2100,
 216         Bmcr_Force1000H = 0x0040,
 217         Bmcr_Force1000F = 0x0140,
 218 };
 219
 220 /* auto negotiation advertisement register */
 221 enum anar_bits {
 222         anar_adv_100F = 0x0100,
 223         anar_adv_100H = 0x0080,
 224         anar_adv_10F = 0x0040,
 225         anar_adv_10H = 0x0020,
 226         anar_ieee_8023 = 0x0001,
 227 };
 228
 229 /* 1K-base T control register */
 230 enum ktcr_bits {
 231         ktcr_adv_1000H = 0x0100,
 232         ktcr_adv_1000F = 0x0200,
 233 };
 234
 235 /* Globals */
 236 static u32 SavedClkRun;
 237 static unsigned int cur_rx;
 238 static unsigned int rx_config;
 239 static unsigned int tx_config;
 240
 241 /* Note: transmit and receive buffers and descriptors must be
 242    long long word aligned */
 243 static BufferDesc txd __attribute__ ((aligned(8)));
 244 static BufferDesc rxd[NUM_RX_DESC] __attribute__ ((aligned(8)));
 245 static unsigned char txb[TX_BUF_SIZE] __attribute__ ((aligned(8)));
 246 static unsigned char rxb[NUM_RX_DESC * RX_BUF_SIZE]
 247     __attribute__ ((aligned(8)));
 248
 249 /* Function Prototypes */
 250 static int mdio_read(struct eth_device *dev, int phy_id, int addr);
 251 static void mdio_write(struct eth_device *dev, int phy_id, int addr, int value);
 252 static void mdio_sync(struct eth_device *dev, u32 offset);
 253 static int ns8382x_init(struct eth_device *dev, bd_t * bis);
 254 static void ns8382x_reset(struct eth_device *dev);
 255 static void ns8382x_init_rxfilter(struct eth_device *dev);
 256 static void ns8382x_init_txd(struct eth_device *dev);
 257 static void ns8382x_init_rxd(struct eth_device *dev);
 258 static void ns8382x_set_rx_mode(struct eth_device *dev);
 259 static void ns8382x_check_duplex(struct eth_device *dev);
 260 static int ns8382x_send(struct eth_device *dev, volatile void *packet,
 261                         int length);
 262 static int ns8382x_poll(struct eth_device *dev);
 263 static void ns8382x_disable(struct eth_device *dev);
 264
 265 static struct pci_device_id supported[] = {
 266         {PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_83820},
 267         {}
 268 };
 269
 270 #define bus_to_phys(a)  pci_mem_to_phys((pci_dev_t)dev->priv, a)
 271 #define phys_to_bus(a)  pci_phys_to_mem((pci_dev_t)dev->priv, a)
 272
 273 static inline int
 274 INW(struct eth_device *dev, u_long addr)
 275 {
 276         return le16_to_cpu(*(vu_short *) (addr + dev->iobase));
 277 }
 278
 279 static int
 280 INL(struct eth_device *dev, u_long addr)
 281 {
 282         return le32_to_cpu(*(vu_long *) (addr + dev->iobase));
 283 }
 284
 285 static inline void
 286 OUTW(struct eth_device *dev, int command, u_long addr)
 287 {
 288         *(vu_short *) ((addr + dev->iobase)) = cpu_to_le16(command);
 289 }
 290
 291 static inline void
 292 OUTL(struct eth_device *dev, int command, u_long addr)
 293 {
 294         *(vu_long *) ((addr + dev->iobase)) = cpu_to_le32(command);
 295 }
 296
 297 /* Function: ns8382x_initialize
 298  * Description: Retrieves the MAC address of the card, and sets up some
 299  *  globals required by other routines, and initializes the NIC, making it
 300  *  ready to send and receive packets.
 301  * Side effects: initializes ns8382xs, ready to recieve packets.
 302  * Returns:   int:          number of cards found
 303  */
 304
 305 int
 306 ns8382x_initialize(bd_t * bis)
 307 {
 308         pci_dev_t devno;
 309         int card_number = 0;
 310         struct eth_device *dev;
 311         u32 iobase, status;
 312         int i, idx = 0;
 313         u32 phyAddress;
 314         u32 tmp;
 315         u32 chip_config;
 316
 317         while (1) {             /* Find PCI device(s) */
 318                 if ((devno = pci_find_devices(supported, idx++)) < 0)
 319                         break;
 320
 321                 pci_read_config_dword(devno, PCI_BASE_ADDRESS_1, &iobase);
 322                 iobase &= ~0x3; /* 1: unused and 0:I/O Space Indicator */
 323
 324 #ifdef NS8382X_DEBUG
 325                 printf("ns8382x: NatSemi dp8382x @ 0x%x\n", iobase);
 326 #endif
 327
 328                 pci_write_config_dword(devno, PCI_COMMAND,
 329                                        PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
 330
 331                 /* Check if I/O accesses and Bus Mastering are enabled. */
 332                 pci_read_config_dword(devno, PCI_COMMAND, &status);
 333                 if (!(status & PCI_COMMAND_MEMORY)) {
 334                         printf("Error: Can not enable MEM access.\n");
 335                         continue;
 336                 } else if (!(status & PCI_COMMAND_MASTER)) {
 337                         printf("Error: Can not enable Bus Mastering.\n");
 338                         continue;
 339                 }
 340
 341                 dev = (struct eth_device *) malloc(sizeof *dev);
 342
 343                 sprintf(dev->name, "dp8382x#%d", card_number);
 344                 dev->iobase = bus_to_phys(iobase);
 345                 dev->priv = (void *) devno;
 346                 dev->init = ns8382x_init;
 347                 dev->halt = ns8382x_disable;
 348                 dev->send = ns8382x_send;
 349                 dev->recv = ns8382x_poll;
 350
 351                 /* ns8382x has a non-standard PM control register
 352                  * in PCI config space.  Some boards apparently need
 353                  * to be brought to D0 in this manner.  */
 354                 pci_read_config_dword(devno, PCIPM, &tmp);
 355                 if (tmp & (0x03 | 0x100)) {     /* D0 state, disable PME assertion */
 356                         u32 newtmp = tmp & ~(0x03 | 0x100);
 357                         pci_write_config_dword(devno, PCIPM, newtmp);
 358                 }
 359
 360                 /* get MAC address */
 361                 for (i = 0; i < 3; i++) {
 362                         u32 data;
 363                         char *mac = (char *)&dev->enetaddr[i * 2];
 364
 365                         OUTL(dev, i * 2, RxFilterAddr);
 366                         data = INL(dev, RxFilterData);
 367                         *mac++ = data;
 368                         *mac++ = data >> 8;
 369                 }
 370                 /* get PHY address, can't be zero */
 371                 for (phyAddress = 1; phyAddress < 32; phyAddress++) {
 372                         u32 rev, phy1;
 373
 374                         phy1 = mdio_read(dev, phyAddress, PHYIDR1);
 375                         if (phy1 == 0x2000) {   /*check for 83861/91 */
 376                                 rev = mdio_read(dev, phyAddress, PHYIDR2);
 377                                 if ((rev & ~(0x000f)) == 0x00005c50 ||
 378                                     (rev & ~(0x000f)) == 0x00005c60) {
 379 #ifdef NS8382X_DEBUG
 380                                         printf("phy rev is %x\n", rev);
 381                                         printf("phy address is %x\n",
 382                                                phyAddress);
 383 #endif
 384                                         break;
 385                                 }
 386                         }
 387                 }
 388
 389                 /* set phy to autonegotiate && advertise everything */
 390                 mdio_write(dev, phyAddress, KTCR,
 391                            (ktcr_adv_1000H | ktcr_adv_1000F));
 392                 mdio_write(dev, phyAddress, ANAR,
 393                            (anar_adv_100F | anar_adv_100H | anar_adv_10H |
 394                             anar_adv_10F | anar_ieee_8023));
 395                 mdio_write(dev, phyAddress, BMCR, 0x0); /*restore */
 396                 mdio_write(dev, phyAddress, BMCR,
 397                            (Bmcr_AutoNegEn | Bmcr_RstAutoNeg));
 398                 /* Reset the chip to erase any previous misconfiguration. */
 399                 OUTL(dev, (ChipReset), ChipCmd);
 400
 401                 chip_config = INL(dev, ChipConfig);
 402                 /* reset the phy */
 403                 OUTL(dev, (chip_config | PhyRst), ChipConfig);
 404                 /* power up and initialize transceiver */
 405                 OUTL(dev, (chip_config & ~(PhyDis)), ChipConfig);
 406
 407                 mdio_sync(dev, EECtrl);
 408 #ifdef NS8382X_DEBUG
 409                 {
 410                         u32 chpcfg =
 411                             INL(dev, ChipConfig) ^ SpeedStatus_Polarity;
 412
 413                         printf("%s: Transceiver 10%s %s duplex.\n", dev->name,
 414                                (chpcfg & GigSpeed) ? "00" : (chpcfg & HundSpeed)
 415                                ? "0" : "",
 416                                chpcfg & FullDuplex ? "full" : "half");
 417                         printf("%s: %02x:%02x:%02x:%02x:%02x:%02x\n", dev->name,
 418                                dev->enetaddr[0], dev->enetaddr[1],
 419                                dev->enetaddr[2], dev->enetaddr[3],
 420                                dev->enetaddr[4], dev->enetaddr[5]);
 421                 }
 422 #endif
 423                 /* Disable PME:
 424                  * The PME bit is initialized from the EEPROM contents.
 425                  * PCI cards probably have PME disabled, but motherboard
 426                  * implementations may have PME set to enable WakeOnLan.
 427                  * With PME set the chip will scan incoming packets but
 428                  * nothing will be written to memory. */
 429                 SavedClkRun = INL(dev, ClkRun);
 430                 OUTL(dev, SavedClkRun & ~0x100, ClkRun);
 431
 432                 eth_register(dev);
 433
 434                 card_number++;
 435
 436                 pci_write_config_byte(devno, PCI_LATENCY_TIMER, 0x60);
 437
 438                 udelay(10 * 1000);
 439         }
 440         return card_number;
 441 }
 442
 443 /*  MII transceiver control section.
 444         Read and write MII registers using software-generated serial MDIO
 445         protocol.  See the MII specifications or DP83840A data sheet for details.
 446
 447         The maximum data clock rate is 2.5 Mhz.  To meet minimum timing we
 448         must flush writes to the PCI bus with a PCI read. */
 449 #define mdio_delay(mdio_addr) INL(dev, mdio_addr)
 450
 451 #define MDIO_EnbIn  (0)
 452 #define MDIO_WRITE0 (MDIO_EnbOutput)
 453 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
 454
 455 /* Generate the preamble required for initial synchronization and
 456    a few older transceivers. */
 457 static void
 458 mdio_sync(struct eth_device *dev, u32 offset)
 459 {
 460         int bits = 32;
 461
 462         /* Establish sync by sending at least 32 logic ones. */
 463         while (--bits >= 0) {
 464                 OUTL(dev, MDIO_WRITE1, offset);
 465                 mdio_delay(offset);
 466                 OUTL(dev, MDIO_WRITE1 | MDIO_ShiftClk, offset);
 467                 mdio_delay(offset);
 468         }
 469 }
 470
 471 static int
 472 mdio_read(struct eth_device *dev, int phy_id, int addr)
 473 {
 474         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | addr;
 475         int i, retval = 0;
 476
 477         /* Shift the read command bits out. */
 478         for (i = 15; i >= 0; i--) {
 479                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 480
 481                 OUTL(dev, dataval, EECtrl);
 482                 mdio_delay(EECtrl);
 483                 OUTL(dev, dataval | MDIO_ShiftClk, EECtrl);
 484                 mdio_delay(EECtrl);
 485         }
 486         /* Read the two transition, 16 data, and wire-idle bits. */
 487         for (i = 19; i > 0; i--) {
 488                 OUTL(dev, MDIO_EnbIn, EECtrl);
 489                 mdio_delay(EECtrl);
 490                 retval =
 491                     (retval << 1) | ((INL(dev, EECtrl) & MDIO_Data) ? 1 : 0);
 492                 OUTL(dev, MDIO_EnbIn | MDIO_ShiftClk, EECtrl);
 493                 mdio_delay(EECtrl);
 494         }
 495         return (retval >> 1) & 0xffff;
 496 }
 497
 498 static void
 499 mdio_write(struct eth_device *dev, int phy_id, int addr, int value)
 500 {
 501         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (addr << 18) | value;
 502         int i;
 503
 504         /* Shift the command bits out. */
 505         for (i = 31; i >= 0; i--) {
 506                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 507
 508                 OUTL(dev, dataval, EECtrl);
 509                 mdio_delay(EECtrl);
 510                 OUTL(dev, dataval | MDIO_ShiftClk, EECtrl);
 511                 mdio_delay(EECtrl);
 512         }
 513         /* Clear out extra bits. */
 514         for (i = 2; i > 0; i--) {
 515                 OUTL(dev, MDIO_EnbIn, EECtrl);
 516                 mdio_delay(EECtrl);
 517                 OUTL(dev, MDIO_EnbIn | MDIO_ShiftClk, EECtrl);
 518                 mdio_delay(EECtrl);
 519         }
 520         return;
 521 }
 522
 523 /* Function: ns8382x_init
 524  * Description: resets the ethernet controller chip and configures
 525  *    registers and data structures required for sending and receiving packets.
 526  * Arguments: struct eth_device *dev:       NIC data structure
 527  * returns:     int.
 528  */
 529
 530 static int
 531 ns8382x_init(struct eth_device *dev, bd_t * bis)
 532 {
 533         u32 config;
 534
 535         ns8382x_reset(dev);
 536
 537         /* Disable PME:
 538          * The PME bit is initialized from the EEPROM contents.
 539          * PCI cards probably have PME disabled, but motherboard
 540          * implementations may have PME set to enable WakeOnLan.
 541          * With PME set the chip will scan incoming packets but
 542          * nothing will be written to memory. */
 543         OUTL(dev, SavedClkRun & ~0x100, ClkRun);
 544
 545         ns8382x_init_rxfilter(dev);
 546         ns8382x_init_txd(dev);
 547         ns8382x_init_rxd(dev);
 548
 549         /*set up ChipConfig */
 550         config = INL(dev, ChipConfig);
 551         /*turn off 64 bit ops && Ten-bit interface
 552          * && big-endian mode && extended status */
 553         config &= ~(TBIEn | Mode1000 | T64En | D64En | M64En | BEMode | PhyDis | ExtStEn);
 554         OUTL(dev, config, ChipConfig);
 555
 556         /* Configure the PCI bus bursts and FIFO thresholds. */
 557         tx_config = TxCarrierIgn | TxHeartIgn | TxAutoPad
 558             | TxCollRetry | TxMxdma_1024 | (0x1002);
 559         rx_config = RxMxdma_1024 | 0x20;
 560 #ifdef NS8382X_DEBUG
 561         printf("%s: Setting TxConfig Register %#08X\n", dev->name, tx_config);
 562         printf("%s: Setting RxConfig Register %#08X\n", dev->name, rx_config);
 563 #endif
 564         OUTL(dev, tx_config, TxConfig);
 565         OUTL(dev, rx_config, RxConfig);
 566
 567         /*turn off priority queueing */
 568         OUTL(dev, 0x0, PriQueue);
 569
 570         ns8382x_check_duplex(dev);
 571         ns8382x_set_rx_mode(dev);
 572
 573         OUTL(dev, (RxOn | TxOn), ChipCmd);
 574         return 1;
 575 }
 576
 577 /* Function: ns8382x_reset
 578  * Description: soft resets the controller chip
 579  * Arguments: struct eth_device *dev:          NIC data structure
 580  * Returns:   void.
 581  */
 582 static void
 583 ns8382x_reset(struct eth_device *dev)
 584 {
 585         OUTL(dev, ChipReset, ChipCmd);
 586         while (INL(dev, ChipCmd))
 587                 /*wait until done */ ;
 588         OUTL(dev, 0, IntrMask);
 589         OUTL(dev, 0, IntrEnable);
 590 }
 591
 592 /* Function: ns8382x_init_rxfilter
 593  * Description: sets receive filter address to our MAC address
 594  * Arguments: struct eth_device *dev:          NIC data structure
 595  * returns:   void.
 596  */
 597
 598 static void
 599 ns8382x_init_rxfilter(struct eth_device *dev)
 600 {
 601         int i;
 602
 603         for (i = 0; i < ETH_ALEN; i += 2) {
 604                 OUTL(dev, i, RxFilterAddr);
 605                 OUTW(dev, dev->enetaddr[i] + (dev->enetaddr[i + 1] << 8),
 606                      RxFilterData);
 607         }
 608 }
 609
 610 /* Function: ns8382x_init_txd
 611  * Description: initializes the Tx descriptor
 612  * Arguments: struct eth_device *dev:          NIC data structure
 613  * returns:   void.
 614  */
 615
 616 static void
 617 ns8382x_init_txd(struct eth_device *dev)
 618 {
 619         txd.link = (u32) 0;
 620         txd.bufptr = cpu_to_le32((u32) & txb[0]);
 621         txd.cmdsts = (u32) 0;
 622         txd.extsts = (u32) 0;
 623
 624         OUTL(dev, 0x0, TxRingPtrHi);
 625         OUTL(dev, phys_to_bus((u32)&txd), TxRingPtr);
 626 #ifdef NS8382X_DEBUG
 627         printf("ns8382x_init_txd: TX descriptor register loaded with: %#08X (&txd: %p)\n",
 628                INL(dev, TxRingPtr), &txd);
 629 #endif
 630 }
 631
 632 /* Function: ns8382x_init_rxd
 633  * Description: initializes the Rx descriptor ring
 634  * Arguments: struct eth_device *dev:          NIC data structure
 635  * Returns:   void.
 636  */
 637
 638 static void
 639 ns8382x_init_rxd(struct eth_device *dev)
 640 {
 641         int i;
 642
 643         OUTL(dev, 0x0, RxRingPtrHi);
 644
 645         cur_rx = 0;
 646         for (i = 0; i < NUM_RX_DESC; i++) {
 647                 rxd[i].link =
 648                     cpu_to_le32((i + 1 <
 649                                  NUM_RX_DESC) ? (u32) & rxd[i +
 650                                                             1] : (u32) &
 651                                 rxd[0]);
 652                 rxd[i].extsts = cpu_to_le32((u32) 0x0);
 653                 rxd[i].cmdsts = cpu_to_le32((u32) RX_BUF_SIZE);
 654                 rxd[i].bufptr = cpu_to_le32((u32) & rxb[i * RX_BUF_SIZE]);
 655 #ifdef NS8382X_DEBUG
 656                 printf
 657                     ("ns8382x_init_rxd: rxd[%d]=%p link=%X cmdsts=%X bufptr=%X\n",
 658                      i, &rxd[i], le32_to_cpu(rxd[i].link),
 659                      le32_to_cpu(rxd[i].cmdsts), le32_to_cpu(rxd[i].bufptr));
 660 #endif
 661         }
 662         OUTL(dev, phys_to_bus((u32) & rxd), RxRingPtr);
 663
 664 #ifdef NS8382X_DEBUG
 665         printf("ns8382x_init_rxd: RX descriptor register loaded with: %X\n",
 666                INL(dev, RxRingPtr));
 667 #endif
 668 }
 669
 670 /* Function: ns8382x_set_rx_mode
 671  * Description:
 672  *    sets the receive mode to accept all broadcast packets and packets
 673  *    with our MAC address, and reject all multicast packets.
 674  * Arguments: struct eth_device *dev:          NIC data structure
 675  * Returns:   void.
 676  */
 677
 678 static void
 679 ns8382x_set_rx_mode(struct eth_device *dev)
 680 {
 681         u32 rx_mode = 0x0;
 682         /*spec says RxFilterEnable has to be 0 for rest of
 683          * this stuff to be properly configured. Linux driver
 684          * seems to support this*/
 685 /*      OUTL(dev, rx_mode, RxFilterAddr);*/
 686         rx_mode = (RxFilterEnable | AcceptAllBroadcast | AcceptPerfectMatch);
 687         OUTL(dev, rx_mode, RxFilterAddr);
 688         printf("ns8382x_set_rx_mode: set to %X\n", rx_mode);
 689         /*now we turn RxFilterEnable back on */
 690         /*rx_mode |= RxFilterEnable;
 691         OUTL(dev, rx_mode, RxFilterAddr);*/
 692 }
 693
 694 static void
 695 ns8382x_check_duplex(struct eth_device *dev)
 696 {
 697         int gig = 0;
 698         int hun = 0;
 699         int duplex = 0;
 700         int config = (INL(dev, ChipConfig) ^ SpeedStatus_Polarity);
 701
 702         duplex = (config & FullDuplex) ? 1 : 0;
 703         gig = (config & GigSpeed) ? 1 : 0;
 704         hun = (config & HundSpeed) ? 1 : 0;
 705 #ifdef NS8382X_DEBUG
 706         printf("%s: Setting 10%s %s-duplex based on negotiated link"
 707                " capability.\n", dev->name, (gig) ? "00" : (hun) ? "0" : "",
 708                duplex ? "full" : "half");
 709 #endif
 710         if (duplex) {
 711                 rx_config |= RxAcceptTx;
 712                 tx_config |= (TxCarrierIgn | TxHeartIgn);
 713         } else {
 714                 rx_config &= ~RxAcceptTx;
 715                 tx_config &= ~(TxCarrierIgn | TxHeartIgn);
 716         }
 717 #ifdef NS8382X_DEBUG
 718         printf("%s: Resetting TxConfig Register %#08X\n", dev->name, tx_config);
 719         printf("%s: Resetting RxConfig Register %#08X\n", dev->name, rx_config);
 720 #endif
 721         OUTL(dev, tx_config, TxConfig);
 722         OUTL(dev, rx_config, RxConfig);
 723
 724         /*if speed is 10 or 100, remove MODE1000,
 725          * if it's 1000, then set it */
 726         config = INL(dev, ChipConfig);
 727         if (gig)
 728                 config |= Mode1000;
 729         else
 730                 config &= ~Mode1000;
 731
 732 #ifdef NS8382X_DEBUG
 733         printf("%s: %setting Mode1000\n", dev->name, (gig) ? "S" : "Uns");
 734 #endif
 735         OUTL(dev, config, ChipConfig);
 736 }
 737
 738 /* Function: ns8382x_send
 739  * Description: transmits a packet and waits for completion or timeout.
 740  * Returns:   void.  */
 741 static int
 742 ns8382x_send(struct eth_device *dev, volatile void *packet, int length)
 743 {
 744         u32 i, status = 0;
 745         vu_long tx_stat = 0;
 746
 747         /* Stop the transmitter */
 748         OUTL(dev, TxOff, ChipCmd);
 749 #ifdef NS8382X_DEBUG
 750         printf("ns8382x_send: sending %d bytes\n", (int)length);
 751 #endif
 752
 753         /* set the transmit buffer descriptor and enable Transmit State Machine */
 754         txd.link = cpu_to_le32(0x0);
 755         txd.bufptr = cpu_to_le32(phys_to_bus((u32)packet));
 756         txd.extsts = cpu_to_le32(0x0);
 757         txd.cmdsts = cpu_to_le32(DescOwn | length);
 758
 759         /* load Transmit Descriptor Register */
 760         OUTL(dev, phys_to_bus((u32) & txd), TxRingPtr);
 761 #ifdef NS8382X_DEBUG
 762         printf("ns8382x_send: TX descriptor register loaded with: %#08X\n",
 763                INL(dev, TxRingPtr));
 764         printf("\ttxd.link:%X\tbufp:%X\texsts:%X\tcmdsts:%X\n",
 765                le32_to_cpu(txd.link), le32_to_cpu(txd.bufptr),
 766                le32_to_cpu(txd.extsts), le32_to_cpu(txd.cmdsts));
 767 #endif
 768         /* restart the transmitter */
 769         OUTL(dev, TxOn, ChipCmd);
 770
 771         for (i = 0; (tx_stat = le32_to_cpu(txd.cmdsts)) & DescOwn; i++) {
 772                 if (i >= TOUT_LOOP) {
 773                         printf ("%s: tx error buffer not ready: txd.cmdsts %#X\n",
 774                              dev->name, tx_stat);
 775                         goto Done;
 776                 }
 777         }
 778
 779         if (!(tx_stat & DescPktOK)) {
 780                 printf("ns8382x_send: Transmit error, Tx status %X.\n", tx_stat);
 781                 goto Done;
 782         }
 783 #ifdef NS8382X_DEBUG
 784         printf("ns8382x_send: tx_stat: %#08X\n", tx_stat);
 785 #endif
 786
 787         status = 1;
 788       Done:
 789         return status;
 790 }
 791
 792 /* Function: ns8382x_poll
 793  * Description: checks for a received packet and returns it if found.
 794  * Arguments: struct eth_device *dev:          NIC data structure
 795  * Returns:   1 if    packet was received.
 796  *            0 if no packet was received.
 797  * Side effects:
 798  *            Returns (copies) the packet to the array dev->packet.
 799  *            Returns the length of the packet.
 800  */
 801
 802 static int
 803 ns8382x_poll(struct eth_device *dev)
 804 {
 805         int retstat = 0;
 806         int length = 0;
 807         vu_long rx_status = le32_to_cpu(rxd[cur_rx].cmdsts);
 808
 809         if (!(rx_status & (u32) DescOwn))
 810                 return retstat;
 811 #ifdef NS8382X_DEBUG
 812         printf("ns8382x_poll: got a packet: cur_rx:%u, status:%lx\n",
 813                cur_rx, rx_status);
 814 #endif
 815         length = (rx_status & DSIZE) - CRC_SIZE;
 816
 817         if ((rx_status & (DescMore | DescPktOK | DescRxLong)) != DescPktOK) {
 818                 /* corrupted packet received */
 819                 printf("ns8382x_poll: Corrupted packet, status:%lx\n", rx_status);
 820                 retstat = 0;
 821         } else {
 822                 /* give packet to higher level routine */
 823                 NetReceive((rxb + cur_rx * RX_BUF_SIZE), length);
 824                 retstat = 1;
 825         }
 826
 827         /* return the descriptor and buffer to receive ring */
 828         rxd[cur_rx].cmdsts = cpu_to_le32(RX_BUF_SIZE);
 829         rxd[cur_rx].bufptr = cpu_to_le32((u32) & rxb[cur_rx * RX_BUF_SIZE]);
 830
 831         if (++cur_rx == NUM_RX_DESC)
 832                 cur_rx = 0;
 833
 834         /* re-enable the potentially idle receive state machine */
 835         OUTL(dev, RxOn, ChipCmd);
 836
 837         return retstat;
 838 }
 839
 840 /* Function: ns8382x_disable
 841  * Description: Turns off interrupts and stops Tx and Rx engines
 842  * Arguments: struct eth_device *dev:          NIC data structure
 843  * Returns:   void.
 844  */
 845
 846 static void
 847 ns8382x_disable(struct eth_device *dev)
 848 {
 849         /* Disable interrupts using the mask. */
 850         OUTL(dev, 0, IntrMask);
 851         OUTL(dev, 0, IntrEnable);
 852
 853         /* Stop the chip's Tx and Rx processes. */
 854         OUTL(dev, (RxOff | TxOff), ChipCmd);
 855
 856         /* Restore PME enable bit */
 857         OUTL(dev, SavedClkRun, ClkRun);
 858 }