src/drivers/net/sundance.c

   1 /**************************************************************************
   2 *
   3 *    sundance.c -- Etherboot device driver for the Sundance ST201 "Alta".
   4 *    Written 2002-2002 by Timothy Legge <tlegge@rogers.com>
   5 *
   6 *    This program is free software; you can redistribute it and/or modify
   7 *    it under the terms of the GNU General Public License as published by
   8 *    the Free Software Foundation; either version 2 of the License, or
   9 *    (at your option) any later version.
  10 *
  11 *    This program is distributed in the hope that it will be useful,
  12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *    GNU General Public License for more details.
  15 *
  16 *    You should have received a copy of the GNU General Public License
  17 *    along with this program; if not, write to the Free Software
  18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 *
  20 *    Portions of this code based on:
  21 *               sundance.c: A Linux device driver for the Sundance ST201 "Alta"
  22 *               Written 1999-2002 by Donald Becker
  23 *
  24 *               tulip.c: Tulip and Clone Etherboot Driver
  25 *               By Marty Conner
  26 *               Copyright (C) 2001 Entity Cyber, Inc.
  27 *
  28 *    Linux Driver Version LK1.09a, 10-Jul-2003 (2.4.25)
  29 *
  30 *    REVISION HISTORY:
  31 *    ================
  32 *    v1.1       01-01-2003      timlegge        Initial implementation
  33 *    v1.7       04-10-2003      timlegge        Transfers Linux Kernel (30 sec)
  34 *    v1.8       04-13-2003      timlegge        Fix multiple transmission bug
  35 *    v1.9       08-19-2003      timlegge        Support Multicast
  36 *    v1.10      01-17-2004      timlegge        Initial driver output cleanup
  37 *    v1.11      03-21-2004      timlegge        Remove unused variables
  38 *    v1.12      03-21-2004      timlegge        Remove excess MII defines
  39 *    v1.13      03-24-2004      timlegge        Update to Linux 2.4.25 driver
  40 *
  41 ****************************************************************************/
  42
  43 /* to get some global routines like printf */
  44 #include "etherboot.h"
  45 /* to get the interface to the body of the program */
  46 #include "nic.h"
  47 /* to get the PCI support functions, if this is a PCI NIC */
  48 #include <gpxe/pci.h>
  49 #include "mii.h"
  50
  51 #define drv_version "v1.12"
  52 #define drv_date "2004-03-21"
  53
  54 #define HZ 100
  55
  56 /* Condensed operations for readability. */
  57 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
  58 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
  59
  60 /* May need to be moved to mii.h */
  61 struct mii_if_info {
  62         int phy_id;
  63         int advertising;
  64         unsigned int full_duplex:1;     /* is full duplex? */
  65 };
  66
  67 /* Set the mtu */
  68 static int mtu = 1514;
  69
  70 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  71    The sundance uses a 64 element hash table based on the Ethernet CRC.  */
  72 // static int multicast_filter_limit = 32;
  73
  74 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  75    Setting to > 1518 effectively disables this feature.
  76    This chip can receive into any byte alignment buffers, so word-oriented
  77    archs do not need a copy-align of the IP header. */
  78 static int rx_copybreak = 0;
  79 static int flowctrl = 1;
  80
  81 /* Allow forcing the media type */
  82 /* media[] specifies the media type the NIC operates at.
  83                  autosense      Autosensing active media.
  84                  10mbps_hd      10Mbps half duplex.
  85                  10mbps_fd      10Mbps full duplex.
  86                  100mbps_hd     100Mbps half duplex.
  87                  100mbps_fd     100Mbps full duplex.
  88 */
  89 static char media[] = "autosense";
  90
  91 /* Operational parameters that are set at compile time. */
  92
  93 /* As Etherboot uses a Polling driver  we can keep the number of rings
  94 to the minimum number required.  In general that is 1 transmit and 4 receive receive rings.  However some cards require that
  95 there be a minimum of 2 rings  */
  96 #define TX_RING_SIZE    2
  97 #define TX_QUEUE_LEN    10      /* Limit ring entries actually used.  */
  98 #define RX_RING_SIZE    4
  99
 100
 101 /* Operational parameters that usually are not changed. */
 102 /* Time in jiffies before concluding the transmitter is hung. */
 103 #define TX_TIME_OUT       (4*HZ)
 104 #define PKT_BUF_SZ      1536
 105
 106 /* Offsets to the device registers.
 107    Unlike software-only systems, device drivers interact with complex hardware.
 108    It's not useful to define symbolic names for every register bit in the
 109    device.  The name can only partially document the semantics and make
 110    the driver longer and more difficult to read.
 111    In general, only the important configuration values or bits changed
 112    multiple times should be defined symbolically.
 113 */
 114 enum alta_offsets {
 115         DMACtrl = 0x00,
 116         TxListPtr = 0x04,
 117         TxDMABurstThresh = 0x08,
 118         TxDMAUrgentThresh = 0x09,
 119         TxDMAPollPeriod = 0x0a,
 120         RxDMAStatus = 0x0c,
 121         RxListPtr = 0x10,
 122         DebugCtrl0 = 0x1a,
 123         DebugCtrl1 = 0x1c,
 124         RxDMABurstThresh = 0x14,
 125         RxDMAUrgentThresh = 0x15,
 126         RxDMAPollPeriod = 0x16,
 127         LEDCtrl = 0x1a,
 128         ASICCtrl = 0x30,
 129         EEData = 0x34,
 130         EECtrl = 0x36,
 131         TxStartThresh = 0x3c,
 132         RxEarlyThresh = 0x3e,
 133         FlashAddr = 0x40,
 134         FlashData = 0x44,
 135         TxStatus = 0x46,
 136         TxFrameId = 0x47,
 137         DownCounter = 0x18,
 138         IntrClear = 0x4a,
 139         IntrEnable = 0x4c,
 140         IntrStatus = 0x4e,
 141         MACCtrl0 = 0x50,
 142         MACCtrl1 = 0x52,
 143         StationAddr = 0x54,
 144         MaxFrameSize = 0x5A,
 145         RxMode = 0x5c,
 146         MIICtrl = 0x5e,
 147         MulticastFilter0 = 0x60,
 148         MulticastFilter1 = 0x64,
 149         RxOctetsLow = 0x68,
 150         RxOctetsHigh = 0x6a,
 151         TxOctetsLow = 0x6c,
 152         TxOctetsHigh = 0x6e,
 153         TxFramesOK = 0x70,
 154         RxFramesOK = 0x72,
 155         StatsCarrierError = 0x74,
 156         StatsLateColl = 0x75,
 157         StatsMultiColl = 0x76,
 158         StatsOneColl = 0x77,
 159         StatsTxDefer = 0x78,
 160         RxMissed = 0x79,
 161         StatsTxXSDefer = 0x7a,
 162         StatsTxAbort = 0x7b,
 163         StatsBcastTx = 0x7c,
 164         StatsBcastRx = 0x7d,
 165         StatsMcastTx = 0x7e,
 166         StatsMcastRx = 0x7f,
 167         /* Aliased and bogus values! */
 168         RxStatus = 0x0c,
 169 };
 170 enum ASICCtrl_HiWord_bit {
 171         GlobalReset = 0x0001,
 172         RxReset = 0x0002,
 173         TxReset = 0x0004,
 174         DMAReset = 0x0008,
 175         FIFOReset = 0x0010,
 176         NetworkReset = 0x0020,
 177         HostReset = 0x0040,
 178         ResetBusy = 0x0400,
 179 };
 180
 181 /* Bits in the interrupt status/mask registers. */
 182 enum intr_status_bits {
 183         IntrSummary = 0x0001, IntrPCIErr = 0x0002, IntrMACCtrl = 0x0008,
 184         IntrTxDone = 0x0004, IntrRxDone = 0x0010, IntrRxStart = 0x0020,
 185         IntrDrvRqst = 0x0040,
 186         StatsMax = 0x0080, LinkChange = 0x0100,
 187         IntrTxDMADone = 0x0200, IntrRxDMADone = 0x0400,
 188 };
 189
 190 /* Bits in the RxMode register. */
 191 enum rx_mode_bits {
 192         AcceptAllIPMulti = 0x20, AcceptMultiHash = 0x10, AcceptAll = 0x08,
 193         AcceptBroadcast = 0x04, AcceptMulticast = 0x02, AcceptMyPhys =
 194             0x01,
 195 };
 196 /* Bits in MACCtrl. */
 197 enum mac_ctrl0_bits {
 198         EnbFullDuplex = 0x20, EnbRcvLargeFrame = 0x40,
 199         EnbFlowCtrl = 0x100, EnbPassRxCRC = 0x200,
 200 };
 201 enum mac_ctrl1_bits {
 202         StatsEnable = 0x0020, StatsDisable = 0x0040, StatsEnabled = 0x0080,
 203         TxEnable = 0x0100, TxDisable = 0x0200, TxEnabled = 0x0400,
 204         RxEnable = 0x0800, RxDisable = 0x1000, RxEnabled = 0x2000,
 205 };
 206
 207 /* The Rx and Tx buffer descriptors.
 208    Using only 32 bit fields simplifies software endian correction.
 209    This structure must be aligned, and should avoid spanning cache lines.
 210 */
 211 struct netdev_desc {
 212         u32 next_desc;
 213         u32 status;
 214         u32 addr;
 215         u32 length;
 216 };
 217
 218 /* Bits in netdev_desc.status */
 219 enum desc_status_bits {
 220         DescOwn = 0x8000,
 221         DescEndPacket = 0x4000,
 222         DescEndRing = 0x2000,
 223         LastFrag = 0x80000000,
 224         DescIntrOnTx = 0x8000,
 225         DescIntrOnDMADone = 0x80000000,
 226         DisableAlign = 0x00000001,
 227 };
 228
 229 /**********************************************
 230 * Descriptor Ring and Buffer defination
 231 ***********************************************/
 232 /* Define the TX Descriptor */
 233 static struct netdev_desc tx_ring[TX_RING_SIZE];
 234
 235 /* Define the RX Descriptor */
 236 static struct netdev_desc rx_ring[RX_RING_SIZE];
 237
 238 /* Create a static buffer of size PKT_BUF_SZ for each RX and TX descriptor.
 239    All descriptors point to a part of this buffer */
 240 struct {
 241         unsigned char txb[PKT_BUF_SZ * TX_RING_SIZE];
 242         unsigned char rxb[RX_RING_SIZE * PKT_BUF_SZ];
 243 } rx_tx_buf __shared;
 244 #define rxb rx_tx_buf.rxb
 245 #define txb rx_tx_buf.txb
 246
 247 /* FIXME: Move BASE to the private structure */
 248 static u32 BASE;
 249 #define EEPROM_SIZE     128
 250
 251 enum pci_id_flags_bits {
 252         PCI_USES_IO = 1, PCI_USES_MEM = 2, PCI_USES_MASTER = 4,
 253         PCI_ADDR0 = 0 << 4, PCI_ADDR1 = 1 << 4, PCI_ADDR2 =
 254             2 << 4, PCI_ADDR3 = 3 << 4,
 255 };
 256
 257 enum chip_capability_flags { CanHaveMII = 1, KendinPktDropBug = 2, };
 258 #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO  | PCI_ADDR0)
 259
 260 #define MII_CNT         4
 261 static struct sundance_private {
 262         const char *nic_name;
 263         /* Frequently used values */
 264
 265         unsigned int cur_rx;    /* Producer/consumer ring indicies */
 266         unsigned int mtu;
 267
 268         /* These values keep track of the tranceiver/media in use */
 269         unsigned int flowctrl:1;
 270         unsigned int an_enable:1;
 271
 272         unsigned int speed;
 273
 274         /* MII tranceiver section */
 275         struct mii_if_info mii_if;
 276         int mii_preamble_required;
 277         unsigned char phys[MII_CNT];
 278         unsigned char pci_rev_id;
 279 } sdx;
 280
 281 static struct sundance_private *sdc;
 282
 283 /* Station Address location within the EEPROM */
 284 #define EEPROM_SA_OFFSET        0x10
 285 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
 286                         IntrDrvRqst | IntrTxDone | StatsMax | \
 287                         LinkChange)
 288
 289 static int eeprom_read(long ioaddr, int location);
 290 static int mdio_read(struct nic *nic, int phy_id, unsigned int location);
 291 static void mdio_write(struct nic *nic, int phy_id, unsigned int location,
 292                        int value);
 293 static void set_rx_mode(struct nic *nic);
 294
 295 static void check_duplex(struct nic *nic)
 296 {
 297         int mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
 298         int negotiated = mii_lpa & sdc->mii_if.advertising;
 299         int duplex;
 300
 301         /* Force media */
 302         if (!sdc->an_enable || mii_lpa == 0xffff) {
 303                 if (sdc->mii_if.full_duplex)
 304                         outw(inw(BASE + MACCtrl0) | EnbFullDuplex,
 305                              BASE + MACCtrl0);
 306                 return;
 307         }
 308
 309         /* Autonegotiation */
 310         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
 311         if (sdc->mii_if.full_duplex != duplex) {
 312                 sdc->mii_if.full_duplex = duplex;
 313                 DBG ("%s: Setting %s-duplex based on MII #%d "
 314                          "negotiated capability %4.4x.\n", sdc->nic_name,
 315                          duplex ? "full" : "half", sdc->phys[0],
 316                          negotiated );
 317                 outw(inw(BASE + MACCtrl0) | duplex ? 0x20 : 0,
 318                      BASE + MACCtrl0);
 319         }
 320 }
 321
 322
 323 /**************************************************************************
 324  *  init_ring - setup the tx and rx descriptors
 325  *************************************************************************/
 326 static void init_ring(struct nic *nic __unused)
 327 {
 328         int i;
 329
 330         sdc->cur_rx = 0;
 331
 332         /* Initialize all the Rx descriptors */
 333         for (i = 0; i < RX_RING_SIZE; i++) {
 334                 rx_ring[i].next_desc = virt_to_le32desc(&rx_ring[i + 1]);
 335                 rx_ring[i].status = 0;
 336                 rx_ring[i].length = 0;
 337                 rx_ring[i].addr = 0;
 338         }
 339
 340         /* Mark the last entry as wrapping the ring */
 341         rx_ring[i - 1].next_desc = virt_to_le32desc(&rx_ring[0]);
 342
 343         for (i = 0; i < RX_RING_SIZE; i++) {
 344                 rx_ring[i].addr = virt_to_le32desc(&rxb[i * PKT_BUF_SZ]);
 345                 rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
 346         }
 347
 348         /* We only use one transmit buffer, but two
 349          * descriptors so transmit engines have somewhere
 350          * to point should they feel the need */
 351         tx_ring[0].status = 0x00000000;
 352         tx_ring[0].addr = virt_to_bus(&txb[0]);
 353         tx_ring[0].next_desc = 0;       /* virt_to_bus(&tx_ring[1]); */
 354
 355         /* This descriptor is never used */
 356         tx_ring[1].status = 0x00000000;
 357         tx_ring[1].addr = 0;    /*virt_to_bus(&txb[0]); */
 358         tx_ring[1].next_desc = 0;
 359
 360         /* Mark the last entry as wrapping the ring,
 361          * though this should never happen */
 362         tx_ring[1].length = cpu_to_le32(LastFrag | PKT_BUF_SZ);
 363 }
 364
 365 /**************************************************************************
 366  *  RESET - Reset Adapter
 367  * ***********************************************************************/
 368 static void sundance_reset(struct nic *nic)
 369 {
 370         int i;
 371
 372         init_ring(nic);
 373
 374         outl(virt_to_le32desc(&rx_ring[0]), BASE + RxListPtr);
 375         /* The Tx List Pointer is written as packets are queued */
 376
 377         /* Initialize other registers. */
 378         /* __set_mac_addr(dev); */
 379         {
 380                 u16 addr16;
 381
 382                 addr16 = (nic->node_addr[0] | (nic->node_addr[1] << 8));
 383                 outw(addr16, BASE + StationAddr);
 384                 addr16 = (nic->node_addr[2] | (nic->node_addr[3] << 8));
 385                 outw(addr16, BASE + StationAddr + 2);
 386                 addr16 = (nic->node_addr[4] | (nic->node_addr[5] << 8));
 387                 outw(addr16, BASE + StationAddr + 4);
 388         }
 389
 390         outw(sdc->mtu + 14, BASE + MaxFrameSize);
 391         if (sdc->mtu > 2047)    /* this will never happen with default options */
 392                 outl(inl(BASE + ASICCtrl) | 0x0c, BASE + ASICCtrl);
 393
 394         set_rx_mode(nic);
 395
 396         outw(0, BASE + DownCounter);
 397         /* Set the chip to poll every N*30nsec */
 398         outb(100, BASE + RxDMAPollPeriod);
 399
 400         /* Fix DFE-580TX packet drop issue */
 401         if (sdc->pci_rev_id >= 0x14)
 402                 writeb(0x01, BASE + DebugCtrl1);
 403
 404         outw(RxEnable | TxEnable, BASE + MACCtrl1);
 405
 406         /* Construct a perfect filter frame with the mac address as first match
 407          * and broadcast for all others */
 408         for (i = 0; i < 192; i++)
 409                 txb[i] = 0xFF;
 410
 411         txb[0] = nic->node_addr[0];
 412         txb[1] = nic->node_addr[1];
 413         txb[2] = nic->node_addr[2];
 414         txb[3] = nic->node_addr[3];
 415         txb[4] = nic->node_addr[4];
 416         txb[5] = nic->node_addr[5];
 417
 418         DBG ( "%s: Done sundance_reset, status: Rx %hX Tx %hX "
 419               "MAC Control %hX, %hX %hX\n",
 420               sdc->nic_name, (int) inl(BASE + RxStatus),
 421               (int) inw(BASE + TxStatus), (int) inl(BASE + MACCtrl0),
 422               (int) inw(BASE + MACCtrl1), (int) inw(BASE + MACCtrl0) );
 423 }
 424
 425 /**************************************************************************
 426 IRQ - Wait for a frame
 427 ***************************************************************************/
 428 static void sundance_irq ( struct nic *nic, irq_action_t action ) {
 429         unsigned int intr_status;
 430
 431         switch ( action ) {
 432         case DISABLE :
 433         case ENABLE :
 434                 intr_status = inw(nic->ioaddr + IntrStatus);
 435                 intr_status = intr_status & ~DEFAULT_INTR;
 436                 if ( action == ENABLE )
 437                         intr_status = intr_status | DEFAULT_INTR;
 438                 outw(intr_status, nic->ioaddr + IntrEnable);
 439                 break;
 440         case FORCE :
 441                 outw(0x0200, BASE + ASICCtrl);
 442                 break;
 443         }
 444 }
 445 /**************************************************************************
 446 POLL - Wait for a frame
 447 ***************************************************************************/
 448 static int sundance_poll(struct nic *nic, int retreive)
 449 {
 450         /* return true if there's an ethernet packet ready to read */
 451         /* nic->packet should contain data on return */
 452         /* nic->packetlen should contain length of data */
 453         int entry = sdc->cur_rx % RX_RING_SIZE;
 454         u32 frame_status = le32_to_cpu(rx_ring[entry].status);
 455         int intr_status;
 456         int pkt_len = 0;
 457
 458         if (!(frame_status & DescOwn))
 459                 return 0;
 460
 461         /* There is a packet ready */
 462         if(!retreive)
 463                 return 1;
 464
 465         intr_status = inw(nic->ioaddr + IntrStatus);
 466         outw(intr_status, nic->ioaddr + IntrStatus);
 467
 468         pkt_len = frame_status & 0x1fff;
 469
 470         if (frame_status & 0x001f4000) {
 471                 DBG ( "Polling frame_status error\n" ); /* Do we really care about this */
 472         } else {
 473                 if (pkt_len < rx_copybreak) {
 474                         /* FIXME: What should happen Will this ever occur */
 475                         printf("Poll Error: pkt_len < rx_copybreak");
 476                 } else {
 477                         nic->packetlen = pkt_len;
 478                         memcpy(nic->packet, rxb +
 479                                (sdc->cur_rx * PKT_BUF_SZ), nic->packetlen);
 480
 481                 }
 482         }
 483         rx_ring[entry].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
 484         rx_ring[entry].status = 0;
 485         entry++;
 486         sdc->cur_rx = entry % RX_RING_SIZE;
 487         outw(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone),
 488                 nic->ioaddr + IntrStatus);
 489         return 1;
 490 }
 491
 492 /**************************************************************************
 493 TRANSMIT - Transmit a frame
 494 ***************************************************************************/
 495 static void sundance_transmit(struct nic *nic, const char *d,   /* Destination */
 496                               unsigned int t,   /* Type */
 497                               unsigned int s,   /* size */
 498                               const char *p)
 499 {                               /* Packet */
 500         u16 nstype;
 501         u32 to;
 502
 503         /* Disable the Tx */
 504         outw(TxDisable, BASE + MACCtrl1);
 505
 506         memcpy(txb, d, ETH_ALEN);
 507         memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
 508         nstype = htons((u16) t);
 509         memcpy(txb + 2 * ETH_ALEN, (u8 *) & nstype, 2);
 510         memcpy(txb + ETH_HLEN, p, s);
 511
 512         s += ETH_HLEN;
 513         s &= 0x0FFF;
 514         while (s < ETH_ZLEN)
 515                 txb[s++] = '\0';
 516
 517         /* Setup the transmit descriptor */
 518         tx_ring[0].length = cpu_to_le32(s | LastFrag);
 519         tx_ring[0].status = cpu_to_le32(0x00000001);
 520
 521         /* Point to transmit descriptor */
 522         outl(virt_to_le32desc(&tx_ring[0]), BASE + TxListPtr);
 523
 524         /* Enable Tx */
 525         outw(TxEnable, BASE + MACCtrl1);
 526         /* Trigger an immediate send */
 527         outw(0, BASE + TxStatus);
 528
 529         to = currticks() + TX_TIME_OUT;
 530         while (!(tx_ring[0].status & 0x00010000) && (currticks() < to));        /* wait */
 531
 532         if (currticks() >= to) {
 533                 printf("TX Time Out");
 534         }
 535         /* Disable Tx */
 536         outw(TxDisable, BASE + MACCtrl1);
 537
 538 }
 539
 540 /**************************************************************************
 541 DISABLE - Turn off ethernet interface
 542 ***************************************************************************/
 543 static void sundance_disable ( struct nic *nic __unused ) {
 544         /* put the card in its initial state */
 545         /* This function serves 3 purposes.
 546          * This disables DMA and interrupts so we don't receive
 547          *  unexpected packets or interrupts from the card after
 548          *  etherboot has finished.
 549          * This frees resources so etherboot may use
 550          *  this driver on another interface
 551          * This allows etherboot to reinitialize the interface
 552          *  if something is something goes wrong.
 553          */
 554         outw(0x0000, BASE + IntrEnable);
 555         /* Stop the Chipchips Tx and Rx Status */
 556         outw(TxDisable | RxDisable | StatsDisable, BASE + MACCtrl1);
 557 }
 558
 559 static struct nic_operations sundance_operations = {
 560         .connect        = dummy_connect,
 561         .poll           = sundance_poll,
 562         .transmit       = sundance_transmit,
 563         .irq            = sundance_irq,
 564
 565 };
 566
 567 /**************************************************************************
 568 PROBE - Look for an adapter, this routine's visible to the outside
 569 ***************************************************************************/
 570 static int sundance_probe ( struct nic *nic, struct pci_device *pci ) {
 571
 572         u8 ee_data[EEPROM_SIZE];
 573         u16 mii_ctl;
 574         int i;
 575         int speed;
 576
 577         if (pci->ioaddr == 0)
 578                 return 0;
 579
 580         /* BASE is used throughout to address the card */
 581         BASE = pci->ioaddr;
 582         printf(" sundance.c: Found %s Vendor=0x%hX Device=0x%hX\n",
 583                pci->driver_name, pci->vendor, pci->device);
 584
 585         /* Get the MAC Address by reading the EEPROM */
 586         for (i = 0; i < 3; i++) {
 587                 ((u16 *) ee_data)[i] =
 588                     le16_to_cpu(eeprom_read(BASE, i + EEPROM_SA_OFFSET));
 589         }
 590         /* Update the nic structure with the MAC Address */
 591         for (i = 0; i < ETH_ALEN; i++) {
 592                 nic->node_addr[i] = ee_data[i];
 593         }
 594
 595         /* Set the card as PCI Bus Master */
 596         adjust_pci_device(pci);
 597
 598 //      sdc->mii_if.dev = pci;
 599 //      sdc->mii_if.phy_id_mask = 0x1f;
 600 //      sdc->mii_if.reg_num_mask = 0x1f;
 601
 602         /* point to private storage */
 603         sdc = &sdx;
 604
 605         sdc->nic_name = pci->driver_name;
 606         sdc->mtu = mtu;
 607
 608         pci_read_config_byte(pci, PCI_REVISION_ID, &sdc->pci_rev_id);
 609
 610         DBG ( "Device revision id: %hx\n", sdc->pci_rev_id );
 611
 612         /* Print out some hardware info */
 613         DBG ( "%s: %s at ioaddr %hX, ", pci->driver_name, nic->node_addr, (unsigned int) BASE);
 614
 615         sdc->mii_preamble_required = 0;
 616         if (1) {
 617                 int phy, phy_idx = 0;
 618                 sdc->phys[0] = 1;       /* Default Setting */
 619                 sdc->mii_preamble_required++;
 620                 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
 621                         int mii_status = mdio_read(nic, phy, MII_BMSR);
 622                         if (mii_status != 0xffff && mii_status != 0x0000) {
 623                                 sdc->phys[phy_idx++] = phy;
 624                                 sdc->mii_if.advertising =
 625                                     mdio_read(nic, phy, MII_ADVERTISE);
 626                                 if ((mii_status & 0x0040) == 0)
 627                                         sdc->mii_preamble_required++;
 628                                 DBG
 629                                     ( "%s: MII PHY found at address %d, status " "%hX advertising %hX\n", sdc->nic_name, phy, mii_status, sdc->mii_if.advertising );
 630                         }
 631                 }
 632                 sdc->mii_preamble_required--;
 633                 if (phy_idx == 0)
 634                         printf("%s: No MII transceiver found!\n",
 635                                sdc->nic_name);
 636                 sdc->mii_if.phy_id = sdc->phys[0];
 637         }
 638
 639         /* Parse override configuration */
 640         sdc->an_enable = 1;
 641         if (strcasecmp(media, "autosense") != 0) {
 642                 sdc->an_enable = 0;
 643                 if (strcasecmp(media, "100mbps_fd") == 0 ||
 644                     strcasecmp(media, "4") == 0) {
 645                         sdc->speed = 100;
 646                         sdc->mii_if.full_duplex = 1;
 647                 } else if (strcasecmp(media, "100mbps_hd") == 0
 648                            || strcasecmp(media, "3") == 0) {
 649                         sdc->speed = 100;
 650                         sdc->mii_if.full_duplex = 0;
 651                 } else if (strcasecmp(media, "10mbps_fd") == 0 ||
 652                            strcasecmp(media, "2") == 0) {
 653                         sdc->speed = 10;
 654                         sdc->mii_if.full_duplex = 1;
 655                 } else if (strcasecmp(media, "10mbps_hd") == 0 ||
 656                            strcasecmp(media, "1") == 0) {
 657                         sdc->speed = 10;
 658                         sdc->mii_if.full_duplex = 0;
 659                 } else {
 660                         sdc->an_enable = 1;
 661                 }
 662         }
 663         if (flowctrl == 1)
 664                 sdc->flowctrl = 1;
 665
 666         /* Fibre PHY? */
 667         if (inl(BASE + ASICCtrl) & 0x80) {
 668                 /* Default 100Mbps Full */
 669                 if (sdc->an_enable) {
 670                         sdc->speed = 100;
 671                         sdc->mii_if.full_duplex = 1;
 672                         sdc->an_enable = 0;
 673                 }
 674         }
 675
 676         /* The Linux driver uses flow control and resets the link here.  This means the
 677            mii section from above would need to be re done I believe.  Since it serves
 678            no real purpose leave it out. */
 679
 680         /* Force media type */
 681         if (!sdc->an_enable) {
 682                 mii_ctl = 0;
 683                 mii_ctl |= (sdc->speed == 100) ? BMCR_SPEED100 : 0;
 684                 mii_ctl |= (sdc->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
 685                 mdio_write(nic, sdc->phys[0], MII_BMCR, mii_ctl);
 686                 printf("Override speed=%d, %s duplex\n",
 687                        sdc->speed,
 688                        sdc->mii_if.full_duplex ? "Full" : "Half");
 689         }
 690
 691         /* Reset the chip to erase previous misconfiguration */
 692         DBG ( "ASIC Control is %#x\n", inl(BASE + ASICCtrl) );
 693         outw(0x007f, BASE + ASICCtrl + 2);
 694
 695         /*
 696         * wait for reset to complete
 697         * this is heavily inspired by the linux sundance driver
 698         * according to the linux driver it can take up to 1ms for the reset
 699         * to complete
 700         */
 701         i = 0;
 702         while(inl(BASE + ASICCtrl) & (ResetBusy << 16)) {
 703                 if(i++ >= 10) {
 704                         DBG("sundance: NIC reset did not complete.\n");
 705                         break;
 706                 }
 707                 udelay(100);
 708         }
 709
 710         DBG ( "ASIC Control is now %#x.\n", inl(BASE + ASICCtrl) );
 711
 712         sundance_reset(nic);
 713         if (sdc->an_enable) {
 714                 u16 mii_advertise, mii_lpa;
 715                 mii_advertise =
 716                     mdio_read(nic, sdc->phys[0], MII_ADVERTISE);
 717                 mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
 718                 mii_advertise &= mii_lpa;
 719                 if (mii_advertise & ADVERTISE_100FULL)
 720                         sdc->speed = 100;
 721                 else if (mii_advertise & ADVERTISE_100HALF)
 722                         sdc->speed = 100;
 723                 else if (mii_advertise & ADVERTISE_10FULL)
 724                         sdc->speed = 10;
 725                 else if (mii_advertise & ADVERTISE_10HALF)
 726                         sdc->speed = 10;
 727         } else {
 728                 mii_ctl = mdio_read(nic, sdc->phys[0], MII_BMCR);
 729                 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
 730                 sdc->speed = speed;
 731                 printf("%s: Link changed: %dMbps ,", sdc->nic_name, speed);
 732                 printf("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
 733                        "full" : "half");
 734         }
 735         check_duplex(nic);
 736         if (sdc->flowctrl && sdc->mii_if.full_duplex) {
 737                 outw(inw(BASE + MulticastFilter1 + 2) | 0x0200,
 738                      BASE + MulticastFilter1 + 2);
 739                 outw(inw(BASE + MACCtrl0) | EnbFlowCtrl, BASE + MACCtrl0);
 740         }
 741         printf("%dMbps, %s-Duplex\n", sdc->speed,
 742                sdc->mii_if.full_duplex ? "Full" : "Half");
 743
 744         /* point to NIC specific routines */
 745         nic->nic_op     = &sundance_operations;
 746
 747         nic->irqno  = pci->irq;
 748         nic->ioaddr = BASE;
 749
 750         return 1;
 751 }
 752
 753
 754 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
 755 static int eeprom_read(long ioaddr, int location)
 756 {
 757         int boguscnt = 10000;   /* Typical 1900 ticks */
 758         outw(0x0200 | (location & 0xff), ioaddr + EECtrl);
 759         do {
 760                 if (!(inw(ioaddr + EECtrl) & 0x8000)) {
 761                         return inw(ioaddr + EEData);
 762                 }
 763         }
 764         while (--boguscnt > 0);
 765         return 0;
 766 }
 767
 768 /*  MII transceiver control section.
 769         Read and write the MII registers using software-generated serial
 770         MDIO protocol.  See the MII specifications or DP83840A data sheet
 771         for details.
 772
 773         The maximum data clock rate is 2.5 Mhz.
 774         The timing is decoupled from the processor clock by flushing the write
 775         from the CPU write buffer with a following read, and using PCI
 776         transaction time. */
 777
 778 #define mdio_in(mdio_addr) inb(mdio_addr)
 779 #define mdio_out(value, mdio_addr) outb(value, mdio_addr)
 780 #define mdio_delay(mdio_addr) inb(mdio_addr)
 781
 782 enum mii_reg_bits {
 783         MDIO_ShiftClk = 0x0001, MDIO_Data = 0x0002, MDIO_EnbOutput =
 784             0x0004,
 785 };
 786 #define MDIO_EnbIn  (0)
 787 #define MDIO_WRITE0 (MDIO_EnbOutput)
 788 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
 789
 790 /* Generate the preamble required for initial synchronization and
 791    a few older transceivers. */
 792 static void mdio_sync(long mdio_addr)
 793 {
 794         int bits = 32;
 795
 796         /* Establish sync by sending at least 32 logic ones. */
 797         while (--bits >= 0) {
 798                 mdio_out(MDIO_WRITE1, mdio_addr);
 799                 mdio_delay(mdio_addr);
 800                 mdio_out(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
 801                 mdio_delay(mdio_addr);
 802         }
 803 }
 804
 805 static int
 806 mdio_read(struct nic *nic __unused, int phy_id, unsigned int location)
 807 {
 808         long mdio_addr = BASE + MIICtrl;
 809         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 810         int i, retval = 0;
 811
 812         if (sdc->mii_preamble_required)
 813                 mdio_sync(mdio_addr);
 814
 815         /* Shift the read command bits out. */
 816         for (i = 15; i >= 0; i--) {
 817                 int dataval =
 818                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 819
 820                 mdio_out(dataval, mdio_addr);
 821                 mdio_delay(mdio_addr);
 822                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
 823                 mdio_delay(mdio_addr);
 824         }
 825         /* Read the two transition, 16 data, and wire-idle bits. */
 826         for (i = 19; i > 0; i--) {
 827                 mdio_out(MDIO_EnbIn, mdio_addr);
 828                 mdio_delay(mdio_addr);
 829                 retval = (retval << 1) | ((mdio_in(mdio_addr) & MDIO_Data)
 830                                           ? 1 : 0);
 831                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 832                 mdio_delay(mdio_addr);
 833         }
 834         return (retval >> 1) & 0xffff;
 835 }
 836
 837 static void
 838 mdio_write(struct nic *nic __unused, int phy_id,
 839            unsigned int location, int value)
 840 {
 841         long mdio_addr = BASE + MIICtrl;
 842         int mii_cmd =
 843             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
 844         int i;
 845
 846         if (sdc->mii_preamble_required)
 847                 mdio_sync(mdio_addr);
 848
 849         /* Shift the command bits out. */
 850         for (i = 31; i >= 0; i--) {
 851                 int dataval =
 852                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 853                 mdio_out(dataval, mdio_addr);
 854                 mdio_delay(mdio_addr);
 855                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
 856                 mdio_delay(mdio_addr);
 857         }
 858         /* Clear out extra bits. */
 859         for (i = 2; i > 0; i--) {
 860                 mdio_out(MDIO_EnbIn, mdio_addr);
 861                 mdio_delay(mdio_addr);
 862                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 863                 mdio_delay(mdio_addr);
 864         }
 865         return;
 866 }
 867
 868 static void set_rx_mode(struct nic *nic __unused)
 869 {
 870         int i;
 871         u16 mc_filter[4];       /* Multicast hash filter */
 872         u32 rx_mode;
 873
 874         memset(mc_filter, 0xff, sizeof(mc_filter));
 875         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 876
 877         if (sdc->mii_if.full_duplex && sdc->flowctrl)
 878                 mc_filter[3] |= 0x0200;
 879         for (i = 0; i < 4; i++)
 880                 outw(mc_filter[i], BASE + MulticastFilter0 + i * 2);
 881         outb(rx_mode, BASE + RxMode);
 882         return;
 883 }
 884
 885 static struct pci_device_id sundance_nics[] = {
 886         PCI_ROM(0x13f0, 0x0201, "sundance", "ST201 Sundance 'Alta' based Adaptor"),
 887         PCI_ROM(0x1186, 0x1002, "dfe530txs", "D-Link DFE530TXS (Sundance ST201 Alta)"),
 888         PCI_ROM(0x13f0, 0x0200, "ip100a", "IC+ IP100A"),
 889 };
 890
 891 PCI_DRIVER ( sundance_driver, sundance_nics, PCI_NO_CLASS );
 892
 893 DRIVER ( "SUNDANCE/PCI", nic_driver, pci_driver, sundance_driver,
 894          sundance_probe, sundance_disable );
 895
 896 /*
 897  * Local variables:
 898  *  c-basic-offset: 8
 899  *  c-indent-level: 8
 900  *  tab-width: 8
 901  * End:
 902  */