drivers/net/ethernet/dlink/sundance.c

   1 /* sundance.c: A Linux device driver for the Sundance ST201 "Alta". */
   2 /*
   3         Written 1999-2000 by Donald Becker.
   4
   5         This software may be used and distributed according to the terms of
   6         the GNU General Public License (GPL), incorporated herein by reference.
   7         Drivers based on or derived from this code fall under the GPL and must
   8         retain the authorship, copyright and license notice.  This file is not
   9         a complete program and may only be used when the entire operating
  10         system is licensed under the GPL.
  11
  12         The author may be reached as [email protected], or C/O
  13         Scyld Computing Corporation
  14         410 Severn Ave., Suite 210
  15         Annapolis MD 21403
  16
  17         Support and updates available at
  18         http://www.scyld.com/network/sundance.html
  19         [link no longer provides useful info -jgarzik]
  20         Archives of the mailing list are still available at
  21         https://www.beowulf.org/pipermail/netdrivers/
  22
  23 */
  24
  25 #define DRV_NAME        "sundance"
  26
  27 /* The user-configurable values.
  28    These may be modified when a driver module is loaded.*/
  29 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  30 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  31    Typical is a 64 element hash table based on the Ethernet CRC.  */
  32 static const int multicast_filter_limit = 32;
  33
  34 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  35    Setting to > 1518 effectively disables this feature.
  36    This chip can receive into offset buffers, so the Alpha does not
  37    need a copy-align. */
  38 static int rx_copybreak;
  39 static int flowctrl=1;
  40
  41 /* media[] specifies the media type the NIC operates at.
  42                  autosense      Autosensing active media.
  43                  10mbps_hd      10Mbps half duplex.
  44                  10mbps_fd      10Mbps full duplex.
  45                  100mbps_hd     100Mbps half duplex.
  46                  100mbps_fd     100Mbps full duplex.
  47                  0              Autosensing active media.
  48                  1              10Mbps half duplex.
  49                  2              10Mbps full duplex.
  50                  3              100Mbps half duplex.
  51                  4              100Mbps full duplex.
  52 */
  53 #define MAX_UNITS 8
  54 static char *media[MAX_UNITS];
  55
  56
  57 /* Operational parameters that are set at compile time. */
  58
  59 /* Keep the ring sizes a power of two for compile efficiency.
  60    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  61    Making the Tx ring too large decreases the effectiveness of channel
  62    bonding and packet priority, and more than 128 requires modifying the
  63    Tx error recovery.
  64    Large receive rings merely waste memory. */
  65 #define TX_RING_SIZE    32
  66 #define TX_QUEUE_LEN    (TX_RING_SIZE - 1) /* Limit ring entries actually used.  */
  67 #define RX_RING_SIZE    64
  68 #define RX_BUDGET       32
  69 #define TX_TOTAL_SIZE   TX_RING_SIZE*sizeof(struct netdev_desc)
  70 #define RX_TOTAL_SIZE   RX_RING_SIZE*sizeof(struct netdev_desc)
  71
  72 /* Operational parameters that usually are not changed. */
  73 /* Time in jiffies before concluding the transmitter is hung. */
  74 #define TX_TIMEOUT  (4*HZ)
  75 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer.*/
  76
  77 /* Include files, designed to support most kernel versions 2.0.0 and later. */
  78 #include <linux/module.h>
  79 #include <linux/kernel.h>
  80 #include <linux/string.h>
  81 #include <linux/timer.h>
  82 #include <linux/errno.h>
  83 #include <linux/ioport.h>
  84 #include <linux/interrupt.h>
  85 #include <linux/pci.h>
  86 #include <linux/netdevice.h>
  87 #include <linux/etherdevice.h>
  88 #include <linux/skbuff.h>
  89 #include <linux/init.h>
  90 #include <linux/bitops.h>
  91 #include <linux/uaccess.h>
  92 #include <asm/processor.h>              /* Processor type for cache alignment. */
  93 #include <asm/io.h>
  94 #include <linux/delay.h>
  95 #include <linux/spinlock.h>
  96 #include <linux/dma-mapping.h>
  97 #include <linux/crc32.h>
  98 #include <linux/ethtool.h>
  99 #include <linux/mii.h>
 100
 101 MODULE_AUTHOR("Donald Becker <[email protected]>");
 102 MODULE_DESCRIPTION("Sundance Alta Ethernet driver");
 103 MODULE_LICENSE("GPL");
 104
 105 module_param(debug, int, 0);
 106 module_param(rx_copybreak, int, 0);
 107 module_param_array(media, charp, NULL, 0);
 108 module_param(flowctrl, int, 0);
 109 MODULE_PARM_DESC(debug, "Sundance Alta debug level (0-5)");
 110 MODULE_PARM_DESC(rx_copybreak, "Sundance Alta copy breakpoint for copy-only-tiny-frames");
 111 MODULE_PARM_DESC(flowctrl, "Sundance Alta flow control [0|1]");
 112
 113 /*
 114                                 Theory of Operation
 115
 116 I. Board Compatibility
 117
 118 This driver is designed for the Sundance Technologies "Alta" ST201 chip.
 119
 120 II. Board-specific settings
 121
 122 III. Driver operation
 123
 124 IIIa. Ring buffers
 125
 126 This driver uses two statically allocated fixed-size descriptor lists
 127 formed into rings by a branch from the final descriptor to the beginning of
 128 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
 129 Some chips explicitly use only 2^N sized rings, while others use a
 130 'next descriptor' pointer that the driver forms into rings.
 131
 132 IIIb/c. Transmit/Receive Structure
 133
 134 This driver uses a zero-copy receive and transmit scheme.
 135 The driver allocates full frame size skbuffs for the Rx ring buffers at
 136 open() time and passes the skb->data field to the chip as receive data
 137 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
 138 a fresh skbuff is allocated and the frame is copied to the new skbuff.
 139 When the incoming frame is larger, the skbuff is passed directly up the
 140 protocol stack.  Buffers consumed this way are replaced by newly allocated
 141 skbuffs in a later phase of receives.
 142
 143 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
 144 using a full-sized skbuff for small frames vs. the copying costs of larger
 145 frames.  New boards are typically used in generously configured machines
 146 and the underfilled buffers have negligible impact compared to the benefit of
 147 a single allocation size, so the default value of zero results in never
 148 copying packets.  When copying is done, the cost is usually mitigated by using
 149 a combined copy/checksum routine.  Copying also preloads the cache, which is
 150 most useful with small frames.
 151
 152 A subtle aspect of the operation is that the IP header at offset 14 in an
 153 ethernet frame isn't longword aligned for further processing.
 154 Unaligned buffers are permitted by the Sundance hardware, so
 155 frames are received into the skbuff at an offset of "+2", 16-byte aligning
 156 the IP header.
 157
 158 IIId. Synchronization
 159
 160 The driver runs as two independent, single-threaded flows of control.  One
 161 is the send-packet routine, which enforces single-threaded use by the
 162 dev->tbusy flag.  The other thread is the interrupt handler, which is single
 163 threaded by the hardware and interrupt handling software.
 164
 165 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
 166 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
 167 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
 168 the 'lp->tx_full' flag.
 169
 170 The interrupt handler has exclusive control over the Rx ring and records stats
 171 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
 172 empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
 173 clears both the tx_full and tbusy flags.
 174
 175 IV. Notes
 176
 177 IVb. References
 178
 179 The Sundance ST201 datasheet, preliminary version.
 180 The Kendin KS8723 datasheet, preliminary version.
 181 The ICplus IP100 datasheet, preliminary version.
 182 http://www.scyld.com/expert/100mbps.html
 183 http://www.scyld.com/expert/NWay.html
 184
 185 IVc. Errata
 186
 187 */
 188
 189 /* Work-around for Kendin chip bugs. */
 190 #ifndef CONFIG_SUNDANCE_MMIO
 191 #define USE_IO_OPS 1
 192 #endif
 193
 194 static const struct pci_device_id sundance_pci_tbl[] = {
 195         { 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
 196         { 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
 197         { 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
 198         { 0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3 },
 199         { 0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
 200         { 0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
 201         { 0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
 202         { }
 203 };
 204 MODULE_DEVICE_TABLE(pci, sundance_pci_tbl);
 205
 206 enum {
 207         netdev_io_size = 128
 208 };
 209
 210 struct pci_id_info {
 211         const char *name;
 212 };
 213 static const struct pci_id_info pci_id_tbl[] = {
 214         {"D-Link DFE-550TX FAST Ethernet Adapter"},
 215         {"D-Link DFE-550FX 100Mbps Fiber-optics Adapter"},
 216         {"D-Link DFE-580TX 4 port Server Adapter"},
 217         {"D-Link DFE-530TXS FAST Ethernet Adapter"},
 218         {"D-Link DL10050-based FAST Ethernet Adapter"},
 219         {"Sundance Technology Alta"},
 220         {"IC Plus Corporation IP100A FAST Ethernet Adapter"},
 221         { }     /* terminate list. */
 222 };
 223
 224 /* This driver was written to use PCI memory space, however x86-oriented
 225    hardware often uses I/O space accesses. */
 226
 227 /* Offsets to the device registers.
 228    Unlike software-only systems, device drivers interact with complex hardware.
 229    It's not useful to define symbolic names for every register bit in the
 230    device.  The name can only partially document the semantics and make
 231    the driver longer and more difficult to read.
 232    In general, only the important configuration values or bits changed
 233    multiple times should be defined symbolically.
 234 */
 235 enum alta_offsets {
 236         DMACtrl = 0x00,
 237         TxListPtr = 0x04,
 238         TxDMABurstThresh = 0x08,
 239         TxDMAUrgentThresh = 0x09,
 240         TxDMAPollPeriod = 0x0a,
 241         RxDMAStatus = 0x0c,
 242         RxListPtr = 0x10,
 243         DebugCtrl0 = 0x1a,
 244         DebugCtrl1 = 0x1c,
 245         RxDMABurstThresh = 0x14,
 246         RxDMAUrgentThresh = 0x15,
 247         RxDMAPollPeriod = 0x16,
 248         LEDCtrl = 0x1a,
 249         ASICCtrl = 0x30,
 250         EEData = 0x34,
 251         EECtrl = 0x36,
 252         FlashAddr = 0x40,
 253         FlashData = 0x44,
 254         WakeEvent = 0x45,
 255         TxStatus = 0x46,
 256         TxFrameId = 0x47,
 257         DownCounter = 0x18,
 258         IntrClear = 0x4a,
 259         IntrEnable = 0x4c,
 260         IntrStatus = 0x4e,
 261         MACCtrl0 = 0x50,
 262         MACCtrl1 = 0x52,
 263         StationAddr = 0x54,
 264         MaxFrameSize = 0x5A,
 265         RxMode = 0x5c,
 266         MIICtrl = 0x5e,
 267         MulticastFilter0 = 0x60,
 268         MulticastFilter1 = 0x64,
 269         RxOctetsLow = 0x68,
 270         RxOctetsHigh = 0x6a,
 271         TxOctetsLow = 0x6c,
 272         TxOctetsHigh = 0x6e,
 273         TxFramesOK = 0x70,
 274         RxFramesOK = 0x72,
 275         StatsCarrierError = 0x74,
 276         StatsLateColl = 0x75,
 277         StatsMultiColl = 0x76,
 278         StatsOneColl = 0x77,
 279         StatsTxDefer = 0x78,
 280         RxMissed = 0x79,
 281         StatsTxXSDefer = 0x7a,
 282         StatsTxAbort = 0x7b,
 283         StatsBcastTx = 0x7c,
 284         StatsBcastRx = 0x7d,
 285         StatsMcastTx = 0x7e,
 286         StatsMcastRx = 0x7f,
 287         /* Aliased and bogus values! */
 288         RxStatus = 0x0c,
 289 };
 290
 291 #define ASIC_HI_WORD(x) ((x) + 2)
 292
 293 enum ASICCtrl_HiWord_bit {
 294         GlobalReset = 0x0001,
 295         RxReset = 0x0002,
 296         TxReset = 0x0004,
 297         DMAReset = 0x0008,
 298         FIFOReset = 0x0010,
 299         NetworkReset = 0x0020,
 300         HostReset = 0x0040,
 301         ResetBusy = 0x0400,
 302 };
 303
 304 /* Bits in the interrupt status/mask registers. */
 305 enum intr_status_bits {
 306         IntrSummary=0x0001, IntrPCIErr=0x0002, IntrMACCtrl=0x0008,
 307         IntrTxDone=0x0004, IntrRxDone=0x0010, IntrRxStart=0x0020,
 308         IntrDrvRqst=0x0040,
 309         StatsMax=0x0080, LinkChange=0x0100,
 310         IntrTxDMADone=0x0200, IntrRxDMADone=0x0400,
 311 };
 312
 313 /* Bits in the RxMode register. */
 314 enum rx_mode_bits {
 315         AcceptAllIPMulti=0x20, AcceptMultiHash=0x10, AcceptAll=0x08,
 316         AcceptBroadcast=0x04, AcceptMulticast=0x02, AcceptMyPhys=0x01,
 317 };
 318 /* Bits in MACCtrl. */
 319 enum mac_ctrl0_bits {
 320         EnbFullDuplex=0x20, EnbRcvLargeFrame=0x40,
 321         EnbFlowCtrl=0x100, EnbPassRxCRC=0x200,
 322 };
 323 enum mac_ctrl1_bits {
 324         StatsEnable=0x0020,     StatsDisable=0x0040, StatsEnabled=0x0080,
 325         TxEnable=0x0100, TxDisable=0x0200, TxEnabled=0x0400,
 326         RxEnable=0x0800, RxDisable=0x1000, RxEnabled=0x2000,
 327 };
 328
 329 /* Bits in WakeEvent register. */
 330 enum wake_event_bits {
 331         WakePktEnable = 0x01,
 332         MagicPktEnable = 0x02,
 333         LinkEventEnable = 0x04,
 334         WolEnable = 0x80,
 335 };
 336
 337 /* The Rx and Tx buffer descriptors. */
 338 /* Note that using only 32 bit fields simplifies conversion to big-endian
 339    architectures. */
 340 struct netdev_desc {
 341         __le32 next_desc;
 342         __le32 status;
 343         struct desc_frag { __le32 addr, length; } frag;
 344 };
 345
 346 /* Bits in netdev_desc.status */
 347 enum desc_status_bits {
 348         DescOwn=0x8000,
 349         DescEndPacket=0x4000,
 350         DescEndRing=0x2000,
 351         LastFrag=0x80000000,
 352         DescIntrOnTx=0x8000,
 353         DescIntrOnDMADone=0x80000000,
 354         DisableAlign = 0x00000001,
 355 };
 356
 357 #define PRIV_ALIGN      15      /* Required alignment mask */
 358 /* Use  __attribute__((aligned (L1_CACHE_BYTES)))  to maintain alignment
 359    within the structure. */
 360 #define MII_CNT         4
 361 struct netdev_private {
 362         /* Descriptor rings first for alignment. */
 363         struct netdev_desc *rx_ring;
 364         struct netdev_desc *tx_ring;
 365         struct sk_buff* rx_skbuff[RX_RING_SIZE];
 366         struct sk_buff* tx_skbuff[TX_RING_SIZE];
 367         dma_addr_t tx_ring_dma;
 368         dma_addr_t rx_ring_dma;
 369         struct timer_list timer;                /* Media monitoring timer. */
 370         struct net_device *ndev;                /* backpointer */
 371         /* ethtool extra stats */
 372         struct {
 373                 u64 tx_multiple_collisions;
 374                 u64 tx_single_collisions;
 375                 u64 tx_late_collisions;
 376                 u64 tx_deferred;
 377                 u64 tx_deferred_excessive;
 378                 u64 tx_aborted;
 379                 u64 tx_bcasts;
 380                 u64 rx_bcasts;
 381                 u64 tx_mcasts;
 382                 u64 rx_mcasts;
 383         } xstats;
 384         /* Frequently used values: keep some adjacent for cache effect. */
 385         spinlock_t lock;
 386         int msg_enable;
 387         int chip_id;
 388         unsigned int cur_rx, dirty_rx;          /* Producer/consumer ring indices */
 389         unsigned int rx_buf_sz;                 /* Based on MTU+slack. */
 390         struct netdev_desc *last_tx;            /* Last Tx descriptor used. */
 391         unsigned int cur_tx, dirty_tx;
 392         /* These values are keep track of the transceiver/media in use. */
 393         unsigned int flowctrl:1;
 394         unsigned int default_port:4;            /* Last dev->if_port value. */
 395         unsigned int an_enable:1;
 396         unsigned int speed;
 397         unsigned int wol_enabled:1;                     /* Wake on LAN enabled */
 398         struct tasklet_struct rx_tasklet;
 399         struct tasklet_struct tx_tasklet;
 400         int budget;
 401         int cur_task;
 402         /* Multicast and receive mode. */
 403         spinlock_t mcastlock;                   /* SMP lock multicast updates. */
 404         u16 mcast_filter[4];
 405         /* MII transceiver section. */
 406         struct mii_if_info mii_if;
 407         int mii_preamble_required;
 408         unsigned char phys[MII_CNT];            /* MII device addresses, only first one used. */
 409         struct pci_dev *pci_dev;
 410         void __iomem *base;
 411         spinlock_t statlock;
 412 };
 413
 414 /* The station address location in the EEPROM. */
 415 #define EEPROM_SA_OFFSET        0x10
 416 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
 417                         IntrDrvRqst | IntrTxDone | StatsMax | \
 418                         LinkChange)
 419
 420 static int  change_mtu(struct net_device *dev, int new_mtu);
 421 static int  eeprom_read(void __iomem *ioaddr, int location);
 422 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 423 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 424 static int  mdio_wait_link(struct net_device *dev, int wait);
 425 static int  netdev_open(struct net_device *dev);
 426 static void check_duplex(struct net_device *dev);
 427 static void netdev_timer(struct timer_list *t);
 428 static void tx_timeout(struct net_device *dev, unsigned int txqueue);
 429 static void init_ring(struct net_device *dev);
 430 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
 431 static int reset_tx (struct net_device *dev);
 432 static irqreturn_t intr_handler(int irq, void *dev_instance);
 433 static void rx_poll(struct tasklet_struct *t);
 434 static void tx_poll(struct tasklet_struct *t);
 435 static void refill_rx (struct net_device *dev);
 436 static void netdev_error(struct net_device *dev, int intr_status);
 437 static void netdev_error(struct net_device *dev, int intr_status);
 438 static void set_rx_mode(struct net_device *dev);
 439 static int __set_mac_addr(struct net_device *dev);
 440 static int sundance_set_mac_addr(struct net_device *dev, void *data);
 441 static struct net_device_stats *get_stats(struct net_device *dev);
 442 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 443 static int  netdev_close(struct net_device *dev);
 444 static const struct ethtool_ops ethtool_ops;
 445
 446 static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
 447 {
 448         struct netdev_private *np = netdev_priv(dev);
 449         void __iomem *ioaddr = np->base + ASICCtrl;
 450         int countdown;
 451
 452         /* ST201 documentation states ASICCtrl is a 32bit register */
 453         iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
 454         /* ST201 documentation states reset can take up to 1 ms */
 455         countdown = 10 + 1;
 456         while (ioread32 (ioaddr) & (ResetBusy << 16)) {
 457                 if (--countdown == 0) {
 458                         printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
 459                         break;
 460                 }
 461                 udelay(100);
 462         }
 463 }
 464
 465 #ifdef CONFIG_NET_POLL_CONTROLLER
 466 static void sundance_poll_controller(struct net_device *dev)
 467 {
 468         struct netdev_private *np = netdev_priv(dev);
 469
 470         disable_irq(np->pci_dev->irq);
 471         intr_handler(np->pci_dev->irq, dev);
 472         enable_irq(np->pci_dev->irq);
 473 }
 474 #endif
 475
 476 static const struct net_device_ops netdev_ops = {
 477         .ndo_open               = netdev_open,
 478         .ndo_stop               = netdev_close,
 479         .ndo_start_xmit         = start_tx,
 480         .ndo_get_stats          = get_stats,
 481         .ndo_set_rx_mode        = set_rx_mode,
 482         .ndo_eth_ioctl          = netdev_ioctl,
 483         .ndo_tx_timeout         = tx_timeout,
 484         .ndo_change_mtu         = change_mtu,
 485         .ndo_set_mac_address    = sundance_set_mac_addr,
 486         .ndo_validate_addr      = eth_validate_addr,
 487 #ifdef CONFIG_NET_POLL_CONTROLLER
 488         .ndo_poll_controller    = sundance_poll_controller,
 489 #endif
 490 };
 491
 492 static int sundance_probe1(struct pci_dev *pdev,
 493                            const struct pci_device_id *ent)
 494 {
 495         struct net_device *dev;
 496         struct netdev_private *np;
 497         static int card_idx;
 498         int chip_idx = ent->driver_data;
 499         int irq;
 500         int i;
 501         void __iomem *ioaddr;
 502         u16 mii_ctl;
 503         void *ring_space;
 504         dma_addr_t ring_dma;
 505 #ifdef USE_IO_OPS
 506         int bar = 0;
 507 #else
 508         int bar = 1;
 509 #endif
 510         int phy, phy_end, phy_idx = 0;
 511         __le16 addr[ETH_ALEN / 2];
 512
 513         if (pci_enable_device(pdev))
 514                 return -EIO;
 515         pci_set_master(pdev);
 516
 517         irq = pdev->irq;
 518
 519         dev = alloc_etherdev(sizeof(*np));
 520         if (!dev)
 521                 return -ENOMEM;
 522         SET_NETDEV_DEV(dev, &pdev->dev);
 523
 524         if (pci_request_regions(pdev, DRV_NAME))
 525                 goto err_out_netdev;
 526
 527         ioaddr = pci_iomap(pdev, bar, netdev_io_size);
 528         if (!ioaddr)
 529                 goto err_out_res;
 530
 531         for (i = 0; i < 3; i++)
 532                 addr[i] =
 533                         cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
 534         eth_hw_addr_set(dev, (u8 *)addr);
 535
 536         np = netdev_priv(dev);
 537         np->ndev = dev;
 538         np->base = ioaddr;
 539         np->pci_dev = pdev;
 540         np->chip_id = chip_idx;
 541         np->msg_enable = (1 << debug) - 1;
 542         spin_lock_init(&np->lock);
 543         spin_lock_init(&np->statlock);
 544         tasklet_setup(&np->rx_tasklet, rx_poll);
 545         tasklet_setup(&np->tx_tasklet, tx_poll);
 546
 547         ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE,
 548                         &ring_dma, GFP_KERNEL);
 549         if (!ring_space)
 550                 goto err_out_cleardev;
 551         np->tx_ring = (struct netdev_desc *)ring_space;
 552         np->tx_ring_dma = ring_dma;
 553
 554         ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE,
 555                         &ring_dma, GFP_KERNEL);
 556         if (!ring_space)
 557                 goto err_out_unmap_tx;
 558         np->rx_ring = (struct netdev_desc *)ring_space;
 559         np->rx_ring_dma = ring_dma;
 560
 561         np->mii_if.dev = dev;
 562         np->mii_if.mdio_read = mdio_read;
 563         np->mii_if.mdio_write = mdio_write;
 564         np->mii_if.phy_id_mask = 0x1f;
 565         np->mii_if.reg_num_mask = 0x1f;
 566
 567         /* The chip-specific entries in the device structure. */
 568         dev->netdev_ops = &netdev_ops;
 569         dev->ethtool_ops = &ethtool_ops;
 570         dev->watchdog_timeo = TX_TIMEOUT;
 571
 572         /* MTU range: 68 - 8191 */
 573         dev->min_mtu = ETH_MIN_MTU;
 574         dev->max_mtu = 8191;
 575
 576         pci_set_drvdata(pdev, dev);
 577
 578         i = register_netdev(dev);
 579         if (i)
 580                 goto err_out_unmap_rx;
 581
 582         printk(KERN_INFO "%s: %s at %p, %pM, IRQ %d.\n",
 583                dev->name, pci_id_tbl[chip_idx].name, ioaddr,
 584                dev->dev_addr, irq);
 585
 586         np->phys[0] = 1;                /* Default setting */
 587         np->mii_preamble_required++;
 588
 589         /*
 590          * It seems some phys doesn't deal well with address 0 being accessed
 591          * first
 592          */
 593         if (sundance_pci_tbl[np->chip_id].device == 0x0200) {
 594                 phy = 0;
 595                 phy_end = 31;
 596         } else {
 597                 phy = 1;
 598                 phy_end = 32;   /* wraps to zero, due to 'phy & 0x1f' */
 599         }
 600         for (; phy <= phy_end && phy_idx < MII_CNT; phy++) {
 601                 int phyx = phy & 0x1f;
 602                 int mii_status = mdio_read(dev, phyx, MII_BMSR);
 603                 if (mii_status != 0xffff  &&  mii_status != 0x0000) {
 604                         np->phys[phy_idx++] = phyx;
 605                         np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
 606                         if ((mii_status & 0x0040) == 0)
 607                                 np->mii_preamble_required++;
 608                         printk(KERN_INFO "%s: MII PHY found at address %d, status "
 609                                    "0x%4.4x advertising %4.4x.\n",
 610                                    dev->name, phyx, mii_status, np->mii_if.advertising);
 611                 }
 612         }
 613         np->mii_preamble_required--;
 614
 615         if (phy_idx == 0) {
 616                 printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
 617                            dev->name, ioread32(ioaddr + ASICCtrl));
 618                 goto err_out_unregister;
 619         }
 620
 621         np->mii_if.phy_id = np->phys[0];
 622
 623         /* Parse override configuration */
 624         np->an_enable = 1;
 625         if (card_idx < MAX_UNITS) {
 626                 if (media[card_idx] != NULL) {
 627                         np->an_enable = 0;
 628                         if (strcmp (media[card_idx], "100mbps_fd") == 0 ||
 629                             strcmp (media[card_idx], "4") == 0) {
 630                                 np->speed = 100;
 631                                 np->mii_if.full_duplex = 1;
 632                         } else if (strcmp (media[card_idx], "100mbps_hd") == 0 ||
 633                                    strcmp (media[card_idx], "3") == 0) {
 634                                 np->speed = 100;
 635                                 np->mii_if.full_duplex = 0;
 636                         } else if (strcmp (media[card_idx], "10mbps_fd") == 0 ||
 637                                    strcmp (media[card_idx], "2") == 0) {
 638                                 np->speed = 10;
 639                                 np->mii_if.full_duplex = 1;
 640                         } else if (strcmp (media[card_idx], "10mbps_hd") == 0 ||
 641                                    strcmp (media[card_idx], "1") == 0) {
 642                                 np->speed = 10;
 643                                 np->mii_if.full_duplex = 0;
 644                         } else {
 645                                 np->an_enable = 1;
 646                         }
 647                 }
 648                 if (flowctrl == 1)
 649                         np->flowctrl = 1;
 650         }
 651
 652         /* Fibre PHY? */
 653         if (ioread32 (ioaddr + ASICCtrl) & 0x80) {
 654                 /* Default 100Mbps Full */
 655                 if (np->an_enable) {
 656                         np->speed = 100;
 657                         np->mii_if.full_duplex = 1;
 658                         np->an_enable = 0;
 659                 }
 660         }
 661         /* Reset PHY */
 662         mdio_write (dev, np->phys[0], MII_BMCR, BMCR_RESET);
 663         mdelay (300);
 664         /* If flow control enabled, we need to advertise it.*/
 665         if (np->flowctrl)
 666                 mdio_write (dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising | 0x0400);
 667         mdio_write (dev, np->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
 668         /* Force media type */
 669         if (!np->an_enable) {
 670                 mii_ctl = 0;
 671                 mii_ctl |= (np->speed == 100) ? BMCR_SPEED100 : 0;
 672                 mii_ctl |= (np->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
 673                 mdio_write (dev, np->phys[0], MII_BMCR, mii_ctl);
 674                 printk (KERN_INFO "Override speed=%d, %s duplex\n",
 675                         np->speed, np->mii_if.full_duplex ? "Full" : "Half");
 676
 677         }
 678
 679         /* Perhaps move the reset here? */
 680         /* Reset the chip to erase previous misconfiguration. */
 681         if (netif_msg_hw(np))
 682                 printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));
 683         sundance_reset(dev, 0x00ff << 16);
 684         if (netif_msg_hw(np))
 685                 printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));
 686
 687         card_idx++;
 688         return 0;
 689
 690 err_out_unregister:
 691         unregister_netdev(dev);
 692 err_out_unmap_rx:
 693         dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
 694                 np->rx_ring, np->rx_ring_dma);
 695 err_out_unmap_tx:
 696         dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
 697                 np->tx_ring, np->tx_ring_dma);
 698 err_out_cleardev:
 699         pci_iounmap(pdev, ioaddr);
 700 err_out_res:
 701         pci_release_regions(pdev);
 702 err_out_netdev:
 703         free_netdev (dev);
 704         return -ENODEV;
 705 }
 706
 707 static int change_mtu(struct net_device *dev, int new_mtu)
 708 {
 709         if (netif_running(dev))
 710                 return -EBUSY;
 711         dev->mtu = new_mtu;
 712         return 0;
 713 }
 714
 715 #define eeprom_delay(ee_addr)   ioread32(ee_addr)
 716 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
 717 static int eeprom_read(void __iomem *ioaddr, int location)
 718 {
 719         int boguscnt = 10000;           /* Typical 1900 ticks. */
 720         iowrite16(0x0200 | (location & 0xff), ioaddr + EECtrl);
 721         do {
 722                 eeprom_delay(ioaddr + EECtrl);
 723                 if (! (ioread16(ioaddr + EECtrl) & 0x8000)) {
 724                         return ioread16(ioaddr + EEData);
 725                 }
 726         } while (--boguscnt > 0);
 727         return 0;
 728 }
 729
 730 /*  MII transceiver control section.
 731         Read and write the MII registers using software-generated serial
 732         MDIO protocol.  See the MII specifications or DP83840A data sheet
 733         for details.
 734
 735         The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
 736         met by back-to-back 33Mhz PCI cycles. */
 737 #define mdio_delay() ioread8(mdio_addr)
 738
 739 enum mii_reg_bits {
 740         MDIO_ShiftClk=0x0001, MDIO_Data=0x0002, MDIO_EnbOutput=0x0004,
 741 };
 742 #define MDIO_EnbIn  (0)
 743 #define MDIO_WRITE0 (MDIO_EnbOutput)
 744 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
 745
 746 /* Generate the preamble required for initial synchronization and
 747    a few older transceivers. */
 748 static void mdio_sync(void __iomem *mdio_addr)
 749 {
 750         int bits = 32;
 751
 752         /* Establish sync by sending at least 32 logic ones. */
 753         while (--bits >= 0) {
 754                 iowrite8(MDIO_WRITE1, mdio_addr);
 755                 mdio_delay();
 756                 iowrite8(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
 757                 mdio_delay();
 758         }
 759 }
 760
 761 static int mdio_read(struct net_device *dev, int phy_id, int location)
 762 {
 763         struct netdev_private *np = netdev_priv(dev);
 764         void __iomem *mdio_addr = np->base + MIICtrl;
 765         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 766         int i, retval = 0;
 767
 768         if (np->mii_preamble_required)
 769                 mdio_sync(mdio_addr);
 770
 771         /* Shift the read command bits out. */
 772         for (i = 15; i >= 0; i--) {
 773                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 774
 775                 iowrite8(dataval, mdio_addr);
 776                 mdio_delay();
 777                 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
 778                 mdio_delay();
 779         }
 780         /* Read the two transition, 16 data, and wire-idle bits. */
 781         for (i = 19; i > 0; i--) {
 782                 iowrite8(MDIO_EnbIn, mdio_addr);
 783                 mdio_delay();
 784                 retval = (retval << 1) | ((ioread8(mdio_addr) & MDIO_Data) ? 1 : 0);
 785                 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 786                 mdio_delay();
 787         }
 788         return (retval>>1) & 0xffff;
 789 }
 790
 791 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
 792 {
 793         struct netdev_private *np = netdev_priv(dev);
 794         void __iomem *mdio_addr = np->base + MIICtrl;
 795         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
 796         int i;
 797
 798         if (np->mii_preamble_required)
 799                 mdio_sync(mdio_addr);
 800
 801         /* Shift the command bits out. */
 802         for (i = 31; i >= 0; i--) {
 803                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 804
 805                 iowrite8(dataval, mdio_addr);
 806                 mdio_delay();
 807                 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
 808                 mdio_delay();
 809         }
 810         /* Clear out extra bits. */
 811         for (i = 2; i > 0; i--) {
 812                 iowrite8(MDIO_EnbIn, mdio_addr);
 813                 mdio_delay();
 814                 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 815                 mdio_delay();
 816         }
 817 }
 818
 819 static int mdio_wait_link(struct net_device *dev, int wait)
 820 {
 821         int bmsr;
 822         int phy_id;
 823         struct netdev_private *np;
 824
 825         np = netdev_priv(dev);
 826         phy_id = np->phys[0];
 827
 828         do {
 829                 bmsr = mdio_read(dev, phy_id, MII_BMSR);
 830                 if (bmsr & 0x0004)
 831                         return 0;
 832                 mdelay(1);
 833         } while (--wait > 0);
 834         return -1;
 835 }
 836
 837 static int netdev_open(struct net_device *dev)
 838 {
 839         struct netdev_private *np = netdev_priv(dev);
 840         void __iomem *ioaddr = np->base;
 841         const int irq = np->pci_dev->irq;
 842         unsigned long flags;
 843         int i;
 844
 845         sundance_reset(dev, 0x00ff << 16);
 846
 847         i = request_irq(irq, intr_handler, IRQF_SHARED, dev->name, dev);
 848         if (i)
 849                 return i;
 850
 851         if (netif_msg_ifup(np))
 852                 printk(KERN_DEBUG "%s: netdev_open() irq %d\n", dev->name, irq);
 853
 854         init_ring(dev);
 855
 856         iowrite32(np->rx_ring_dma, ioaddr + RxListPtr);
 857         /* The Tx list pointer is written as packets are queued. */
 858
 859         /* Initialize other registers. */
 860         __set_mac_addr(dev);
 861 #if IS_ENABLED(CONFIG_VLAN_8021Q)
 862         iowrite16(dev->mtu + 18, ioaddr + MaxFrameSize);
 863 #else
 864         iowrite16(dev->mtu + 14, ioaddr + MaxFrameSize);
 865 #endif
 866         if (dev->mtu > 2047)
 867                 iowrite32(ioread32(ioaddr + ASICCtrl) | 0x0C, ioaddr + ASICCtrl);
 868
 869         /* Configure the PCI bus bursts and FIFO thresholds. */
 870
 871         if (dev->if_port == 0)
 872                 dev->if_port = np->default_port;
 873
 874         spin_lock_init(&np->mcastlock);
 875
 876         set_rx_mode(dev);
 877         iowrite16(0, ioaddr + IntrEnable);
 878         iowrite16(0, ioaddr + DownCounter);
 879         /* Set the chip to poll every N*320nsec. */
 880         iowrite8(100, ioaddr + RxDMAPollPeriod);
 881         iowrite8(127, ioaddr + TxDMAPollPeriod);
 882         /* Fix DFE-580TX packet drop issue */
 883         if (np->pci_dev->revision >= 0x14)
 884                 iowrite8(0x01, ioaddr + DebugCtrl1);
 885         netif_start_queue(dev);
 886
 887         spin_lock_irqsave(&np->lock, flags);
 888         reset_tx(dev);
 889         spin_unlock_irqrestore(&np->lock, flags);
 890
 891         iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
 892
 893         /* Disable Wol */
 894         iowrite8(ioread8(ioaddr + WakeEvent) | 0x00, ioaddr + WakeEvent);
 895         np->wol_enabled = 0;
 896
 897         if (netif_msg_ifup(np))
 898                 printk(KERN_DEBUG "%s: Done netdev_open(), status: Rx %x Tx %x "
 899                            "MAC Control %x, %4.4x %4.4x.\n",
 900                            dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),
 901                            ioread32(ioaddr + MACCtrl0),
 902                            ioread16(ioaddr + MACCtrl1), ioread16(ioaddr + MACCtrl0));
 903
 904         /* Set the timer to check for link beat. */
 905         timer_setup(&np->timer, netdev_timer, 0);
 906         np->timer.expires = jiffies + 3*HZ;
 907         add_timer(&np->timer);
 908
 909         /* Enable interrupts by setting the interrupt mask. */
 910         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
 911
 912         return 0;
 913 }
 914
 915 static void check_duplex(struct net_device *dev)
 916 {
 917         struct netdev_private *np = netdev_priv(dev);
 918         void __iomem *ioaddr = np->base;
 919         int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
 920         int negotiated = mii_lpa & np->mii_if.advertising;
 921         int duplex;
 922
 923         /* Force media */
 924         if (!np->an_enable || mii_lpa == 0xffff) {
 925                 if (np->mii_if.full_duplex)
 926                         iowrite16 (ioread16 (ioaddr + MACCtrl0) | EnbFullDuplex,
 927                                 ioaddr + MACCtrl0);
 928                 return;
 929         }
 930
 931         /* Autonegotiation */
 932         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
 933         if (np->mii_if.full_duplex != duplex) {
 934                 np->mii_if.full_duplex = duplex;
 935                 if (netif_msg_link(np))
 936                         printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d "
 937                                    "negotiated capability %4.4x.\n", dev->name,
 938                                    duplex ? "full" : "half", np->phys[0], negotiated);
 939                 iowrite16(ioread16(ioaddr + MACCtrl0) | (duplex ? 0x20 : 0), ioaddr + MACCtrl0);
 940         }
 941 }
 942
 943 static void netdev_timer(struct timer_list *t)
 944 {
 945         struct netdev_private *np = from_timer(np, t, timer);
 946         struct net_device *dev = np->mii_if.dev;
 947         void __iomem *ioaddr = np->base;
 948         int next_tick = 10*HZ;
 949
 950         if (netif_msg_timer(np)) {
 951                 printk(KERN_DEBUG "%s: Media selection timer tick, intr status %4.4x, "
 952                            "Tx %x Rx %x.\n",
 953                            dev->name, ioread16(ioaddr + IntrEnable),
 954                            ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));
 955         }
 956         check_duplex(dev);
 957         np->timer.expires = jiffies + next_tick;
 958         add_timer(&np->timer);
 959 }
 960
 961 static void tx_timeout(struct net_device *dev, unsigned int txqueue)
 962 {
 963         struct netdev_private *np = netdev_priv(dev);
 964         void __iomem *ioaddr = np->base;
 965         unsigned long flag;
 966
 967         netif_stop_queue(dev);
 968         tasklet_disable_in_atomic(&np->tx_tasklet);
 969         iowrite16(0, ioaddr + IntrEnable);
 970         printk(KERN_WARNING "%s: Transmit timed out, TxStatus %2.2x "
 971                    "TxFrameId %2.2x,"
 972                    " resetting...\n", dev->name, ioread8(ioaddr + TxStatus),
 973                    ioread8(ioaddr + TxFrameId));
 974
 975         {
 976                 int i;
 977                 for (i=0; i<TX_RING_SIZE; i++) {
 978                         printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
 979                                 (unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)),
 980                                 le32_to_cpu(np->tx_ring[i].next_desc),
 981                                 le32_to_cpu(np->tx_ring[i].status),
 982                                 (le32_to_cpu(np->tx_ring[i].status) >> 2) & 0xff,
 983                                 le32_to_cpu(np->tx_ring[i].frag.addr),
 984                                 le32_to_cpu(np->tx_ring[i].frag.length));
 985                 }
 986                 printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n",
 987                         ioread32(np->base + TxListPtr),
 988                         netif_queue_stopped(dev));
 989                 printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n",
 990                         np->cur_tx, np->cur_tx % TX_RING_SIZE,
 991                         np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
 992                 printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
 993                 printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
 994         }
 995         spin_lock_irqsave(&np->lock, flag);
 996
 997         /* Stop and restart the chip's Tx processes . */
 998         reset_tx(dev);
 999         spin_unlock_irqrestore(&np->lock, flag);
1000
1001         dev->if_port = 0;
1002
1003         netif_trans_update(dev); /* prevent tx timeout */
1004         dev->stats.tx_errors++;
1005         if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1006                 netif_wake_queue(dev);
1007         }
1008         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1009         tasklet_enable(&np->tx_tasklet);
1010 }
1011
1012
1013 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1014 static void init_ring(struct net_device *dev)
1015 {
1016         struct netdev_private *np = netdev_priv(dev);
1017         int i;
1018
1019         np->cur_rx = np->cur_tx = 0;
1020         np->dirty_rx = np->dirty_tx = 0;
1021         np->cur_task = 0;
1022
1023         np->rx_buf_sz = (dev->mtu <= 1520 ? PKT_BUF_SZ : dev->mtu + 16);
1024
1025         /* Initialize all Rx descriptors. */
1026         for (i = 0; i < RX_RING_SIZE; i++) {
1027                 np->rx_ring[i].next_desc = cpu_to_le32(np->rx_ring_dma +
1028                         ((i+1)%RX_RING_SIZE)*sizeof(*np->rx_ring));
1029                 np->rx_ring[i].status = 0;
1030                 np->rx_ring[i].frag.length = 0;
1031                 np->rx_skbuff[i] = NULL;
1032         }
1033
1034         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
1035         for (i = 0; i < RX_RING_SIZE; i++) {
1036                 struct sk_buff *skb =
1037                         netdev_alloc_skb(dev, np->rx_buf_sz + 2);
1038                 np->rx_skbuff[i] = skb;
1039                 if (skb == NULL)
1040                         break;
1041                 skb_reserve(skb, 2);    /* 16 byte align the IP header. */
1042                 np->rx_ring[i].frag.addr = cpu_to_le32(
1043                         dma_map_single(&np->pci_dev->dev, skb->data,
1044                                 np->rx_buf_sz, DMA_FROM_DEVICE));
1045                 if (dma_mapping_error(&np->pci_dev->dev,
1046                                         np->rx_ring[i].frag.addr)) {
1047                         dev_kfree_skb(skb);
1048                         np->rx_skbuff[i] = NULL;
1049                         break;
1050                 }
1051                 np->rx_ring[i].frag.length = cpu_to_le32(np->rx_buf_sz | LastFrag);
1052         }
1053         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1054
1055         for (i = 0; i < TX_RING_SIZE; i++) {
1056                 np->tx_skbuff[i] = NULL;
1057                 np->tx_ring[i].status = 0;
1058         }
1059 }
1060
1061 static void tx_poll(struct tasklet_struct *t)
1062 {
1063         struct netdev_private *np = from_tasklet(np, t, tx_tasklet);
1064         unsigned head = np->cur_task % TX_RING_SIZE;
1065         struct netdev_desc *txdesc =
1066                 &np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE];
1067
1068         /* Chain the next pointer */
1069         for (; np->cur_tx - np->cur_task > 0; np->cur_task++) {
1070                 int entry = np->cur_task % TX_RING_SIZE;
1071                 txdesc = &np->tx_ring[entry];
1072                 if (np->last_tx) {
1073                         np->last_tx->next_desc = cpu_to_le32(np->tx_ring_dma +
1074                                 entry*sizeof(struct netdev_desc));
1075                 }
1076                 np->last_tx = txdesc;
1077         }
1078         /* Indicate the latest descriptor of tx ring */
1079         txdesc->status |= cpu_to_le32(DescIntrOnTx);
1080
1081         if (ioread32 (np->base + TxListPtr) == 0)
1082                 iowrite32 (np->tx_ring_dma + head * sizeof(struct netdev_desc),
1083                         np->base + TxListPtr);
1084 }
1085
1086 static netdev_tx_t
1087 start_tx (struct sk_buff *skb, struct net_device *dev)
1088 {
1089         struct netdev_private *np = netdev_priv(dev);
1090         struct netdev_desc *txdesc;
1091         unsigned entry;
1092
1093         /* Calculate the next Tx descriptor entry. */
1094         entry = np->cur_tx % TX_RING_SIZE;
1095         np->tx_skbuff[entry] = skb;
1096         txdesc = &np->tx_ring[entry];
1097
1098         txdesc->next_desc = 0;
1099         txdesc->status = cpu_to_le32 ((entry << 2) | DisableAlign);
1100         txdesc->frag.addr = cpu_to_le32(dma_map_single(&np->pci_dev->dev,
1101                                 skb->data, skb->len, DMA_TO_DEVICE));
1102         if (dma_mapping_error(&np->pci_dev->dev,
1103                                 txdesc->frag.addr))
1104                         goto drop_frame;
1105         txdesc->frag.length = cpu_to_le32 (skb->len | LastFrag);
1106
1107         /* Increment cur_tx before tasklet_schedule() */
1108         np->cur_tx++;
1109         mb();
1110         /* Schedule a tx_poll() task */
1111         tasklet_schedule(&np->tx_tasklet);
1112
1113         /* On some architectures: explicitly flush cache lines here. */
1114         if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 1 &&
1115             !netif_queue_stopped(dev)) {
1116                 /* do nothing */
1117         } else {
1118                 netif_stop_queue (dev);
1119         }
1120         if (netif_msg_tx_queued(np)) {
1121                 printk (KERN_DEBUG
1122                         "%s: Transmit frame #%d queued in slot %d.\n",
1123                         dev->name, np->cur_tx, entry);
1124         }
1125         return NETDEV_TX_OK;
1126
1127 drop_frame:
1128         dev_kfree_skb_any(skb);
1129         np->tx_skbuff[entry] = NULL;
1130         dev->stats.tx_dropped++;
1131         return NETDEV_TX_OK;
1132 }
1133
1134 /* Reset hardware tx and free all of tx buffers */
1135 static int
1136 reset_tx (struct net_device *dev)
1137 {
1138         struct netdev_private *np = netdev_priv(dev);
1139         void __iomem *ioaddr = np->base;
1140         struct sk_buff *skb;
1141         int i;
1142
1143         /* Reset tx logic, TxListPtr will be cleaned */
1144         iowrite16 (TxDisable, ioaddr + MACCtrl1);
1145         sundance_reset(dev, (NetworkReset|FIFOReset|DMAReset|TxReset) << 16);
1146
1147         /* free all tx skbuff */
1148         for (i = 0; i < TX_RING_SIZE; i++) {
1149                 np->tx_ring[i].next_desc = 0;
1150
1151                 skb = np->tx_skbuff[i];
1152                 if (skb) {
1153                         dma_unmap_single(&np->pci_dev->dev,
1154                                 le32_to_cpu(np->tx_ring[i].frag.addr),
1155                                 skb->len, DMA_TO_DEVICE);
1156                         dev_kfree_skb_any(skb);
1157                         np->tx_skbuff[i] = NULL;
1158                         dev->stats.tx_dropped++;
1159                 }
1160         }
1161         np->cur_tx = np->dirty_tx = 0;
1162         np->cur_task = 0;
1163
1164         np->last_tx = NULL;
1165         iowrite8(127, ioaddr + TxDMAPollPeriod);
1166
1167         iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
1168         return 0;
1169 }
1170
1171 /* The interrupt handler cleans up after the Tx thread,
1172    and schedule a Rx thread work */
1173 static irqreturn_t intr_handler(int irq, void *dev_instance)
1174 {
1175         struct net_device *dev = (struct net_device *)dev_instance;
1176         struct netdev_private *np = netdev_priv(dev);
1177         void __iomem *ioaddr = np->base;
1178         int hw_frame_id;
1179         int tx_cnt;
1180         int tx_status;
1181         int handled = 0;
1182         int i;
1183
1184         do {
1185                 int intr_status = ioread16(ioaddr + IntrStatus);
1186                 iowrite16(intr_status, ioaddr + IntrStatus);
1187
1188                 if (netif_msg_intr(np))
1189                         printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n",
1190                                    dev->name, intr_status);
1191
1192                 if (!(intr_status & DEFAULT_INTR))
1193                         break;
1194
1195                 handled = 1;
1196
1197                 if (intr_status & (IntrRxDMADone)) {
1198                         iowrite16(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone),
1199                                         ioaddr + IntrEnable);
1200                         if (np->budget < 0)
1201                                 np->budget = RX_BUDGET;
1202                         tasklet_schedule(&np->rx_tasklet);
1203                 }
1204                 if (intr_status & (IntrTxDone | IntrDrvRqst)) {
1205                         tx_status = ioread16 (ioaddr + TxStatus);
1206                         for (tx_cnt=32; tx_status & 0x80; --tx_cnt) {
1207                                 if (netif_msg_tx_done(np))
1208                                         printk
1209                                             ("%s: Transmit status is %2.2x.\n",
1210                                         dev->name, tx_status);
1211                                 if (tx_status & 0x1e) {
1212                                         if (netif_msg_tx_err(np))
1213                                                 printk("%s: Transmit error status %4.4x.\n",
1214                                                            dev->name, tx_status);
1215                                         dev->stats.tx_errors++;
1216                                         if (tx_status & 0x10)
1217                                                 dev->stats.tx_fifo_errors++;
1218                                         if (tx_status & 0x08)
1219                                                 dev->stats.collisions++;
1220                                         if (tx_status & 0x04)
1221                                                 dev->stats.tx_fifo_errors++;
1222                                         if (tx_status & 0x02)
1223                                                 dev->stats.tx_window_errors++;
1224
1225                                         /*
1226                                         ** This reset has been verified on
1227                                         ** DFE-580TX boards ! [email protected].
1228                                         */
1229                                         if (tx_status & 0x10) { /* TxUnderrun */
1230                                                 /* Restart Tx FIFO and transmitter */
1231                                                 sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
1232                                                 /* No need to reset the Tx pointer here */
1233                                         }
1234                                         /* Restart the Tx. Need to make sure tx enabled */
1235                                         i = 10;
1236                                         do {
1237                                                 iowrite16(ioread16(ioaddr + MACCtrl1) | TxEnable, ioaddr + MACCtrl1);
1238                                                 if (ioread16(ioaddr + MACCtrl1) & TxEnabled)
1239                                                         break;
1240                                                 mdelay(1);
1241                                         } while (--i);
1242                                 }
1243                                 /* Yup, this is a documentation bug.  It cost me *hours*. */
1244                                 iowrite16 (0, ioaddr + TxStatus);
1245                                 if (tx_cnt < 0) {
1246                                         iowrite32(5000, ioaddr + DownCounter);
1247                                         break;
1248                                 }
1249                                 tx_status = ioread16 (ioaddr + TxStatus);
1250                         }
1251                         hw_frame_id = (tx_status >> 8) & 0xff;
1252                 } else  {
1253                         hw_frame_id = ioread8(ioaddr + TxFrameId);
1254                 }
1255
1256                 if (np->pci_dev->revision >= 0x14) {
1257                         spin_lock(&np->lock);
1258                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1259                                 int entry = np->dirty_tx % TX_RING_SIZE;
1260                                 struct sk_buff *skb;
1261                                 int sw_frame_id;
1262                                 sw_frame_id = (le32_to_cpu(
1263                                         np->tx_ring[entry].status) >> 2) & 0xff;
1264                                 if (sw_frame_id == hw_frame_id &&
1265                                         !(le32_to_cpu(np->tx_ring[entry].status)
1266                                         & 0x00010000))
1267                                                 break;
1268                                 if (sw_frame_id == (hw_frame_id + 1) %
1269                                         TX_RING_SIZE)
1270                                                 break;
1271                                 skb = np->tx_skbuff[entry];
1272                                 /* Free the original skb. */
1273                                 dma_unmap_single(&np->pci_dev->dev,
1274                                         le32_to_cpu(np->tx_ring[entry].frag.addr),
1275                                         skb->len, DMA_TO_DEVICE);
1276                                 dev_consume_skb_irq(np->tx_skbuff[entry]);
1277                                 np->tx_skbuff[entry] = NULL;
1278                                 np->tx_ring[entry].frag.addr = 0;
1279                                 np->tx_ring[entry].frag.length = 0;
1280                         }
1281                         spin_unlock(&np->lock);
1282                 } else {
1283                         spin_lock(&np->lock);
1284                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1285                                 int entry = np->dirty_tx % TX_RING_SIZE;
1286                                 struct sk_buff *skb;
1287                                 if (!(le32_to_cpu(np->tx_ring[entry].status)
1288                                                         & 0x00010000))
1289                                         break;
1290                                 skb = np->tx_skbuff[entry];
1291                                 /* Free the original skb. */
1292                                 dma_unmap_single(&np->pci_dev->dev,
1293                                         le32_to_cpu(np->tx_ring[entry].frag.addr),
1294                                         skb->len, DMA_TO_DEVICE);
1295                                 dev_consume_skb_irq(np->tx_skbuff[entry]);
1296                                 np->tx_skbuff[entry] = NULL;
1297                                 np->tx_ring[entry].frag.addr = 0;
1298                                 np->tx_ring[entry].frag.length = 0;
1299                         }
1300                         spin_unlock(&np->lock);
1301                 }
1302
1303                 if (netif_queue_stopped(dev) &&
1304                         np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1305                         /* The ring is no longer full, clear busy flag. */
1306                         netif_wake_queue (dev);
1307                 }
1308                 /* Abnormal error summary/uncommon events handlers. */
1309                 if (intr_status & (IntrPCIErr | LinkChange | StatsMax))
1310                         netdev_error(dev, intr_status);
1311         } while (0);
1312         if (netif_msg_intr(np))
1313                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1314                            dev->name, ioread16(ioaddr + IntrStatus));
1315         return IRQ_RETVAL(handled);
1316 }
1317
1318 static void rx_poll(struct tasklet_struct *t)
1319 {
1320         struct netdev_private *np = from_tasklet(np, t, rx_tasklet);
1321         struct net_device *dev = np->ndev;
1322         int entry = np->cur_rx % RX_RING_SIZE;
1323         int boguscnt = np->budget;
1324         void __iomem *ioaddr = np->base;
1325         int received = 0;
1326
1327         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1328         while (1) {
1329                 struct netdev_desc *desc = &(np->rx_ring[entry]);
1330                 u32 frame_status = le32_to_cpu(desc->status);
1331                 int pkt_len;
1332
1333                 if (--boguscnt < 0) {
1334                         goto not_done;
1335                 }
1336                 if (!(frame_status & DescOwn))
1337                         break;
1338                 pkt_len = frame_status & 0x1fff;        /* Chip omits the CRC. */
1339                 if (netif_msg_rx_status(np))
1340                         printk(KERN_DEBUG "  netdev_rx() status was %8.8x.\n",
1341                                    frame_status);
1342                 if (frame_status & 0x001f4000) {
1343                         /* There was a error. */
1344                         if (netif_msg_rx_err(np))
1345                                 printk(KERN_DEBUG "  netdev_rx() Rx error was %8.8x.\n",
1346                                            frame_status);
1347                         dev->stats.rx_errors++;
1348                         if (frame_status & 0x00100000)
1349                                 dev->stats.rx_length_errors++;
1350                         if (frame_status & 0x00010000)
1351                                 dev->stats.rx_fifo_errors++;
1352                         if (frame_status & 0x00060000)
1353                                 dev->stats.rx_frame_errors++;
1354                         if (frame_status & 0x00080000)
1355                                 dev->stats.rx_crc_errors++;
1356                         if (frame_status & 0x00100000) {
1357                                 printk(KERN_WARNING "%s: Oversized Ethernet frame,"
1358                                            " status %8.8x.\n",
1359                                            dev->name, frame_status);
1360                         }
1361                 } else {
1362                         struct sk_buff *skb;
1363 #ifndef final_version
1364                         if (netif_msg_rx_status(np))
1365                                 printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
1366                                            ", bogus_cnt %d.\n",
1367                                            pkt_len, boguscnt);
1368 #endif
1369                         /* Check if the packet is long enough to accept without copying
1370                            to a minimally-sized skbuff. */
1371                         if (pkt_len < rx_copybreak &&
1372                             (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
1373                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1374                                 dma_sync_single_for_cpu(&np->pci_dev->dev,
1375                                                 le32_to_cpu(desc->frag.addr),
1376                                                 np->rx_buf_sz, DMA_FROM_DEVICE);
1377                                 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1378                                 dma_sync_single_for_device(&np->pci_dev->dev,
1379                                                 le32_to_cpu(desc->frag.addr),
1380                                                 np->rx_buf_sz, DMA_FROM_DEVICE);
1381                                 skb_put(skb, pkt_len);
1382                         } else {
1383                                 dma_unmap_single(&np->pci_dev->dev,
1384                                         le32_to_cpu(desc->frag.addr),
1385                                         np->rx_buf_sz, DMA_FROM_DEVICE);
1386                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1387                                 np->rx_skbuff[entry] = NULL;
1388                         }
1389                         skb->protocol = eth_type_trans(skb, dev);
1390                         /* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */
1391                         netif_rx(skb);
1392                 }
1393                 entry = (entry + 1) % RX_RING_SIZE;
1394                 received++;
1395         }
1396         np->cur_rx = entry;
1397         refill_rx (dev);
1398         np->budget -= received;
1399         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1400         return;
1401
1402 not_done:
1403         np->cur_rx = entry;
1404         refill_rx (dev);
1405         if (!received)
1406                 received = 1;
1407         np->budget -= received;
1408         if (np->budget <= 0)
1409                 np->budget = RX_BUDGET;
1410         tasklet_schedule(&np->rx_tasklet);
1411 }
1412
1413 static void refill_rx (struct net_device *dev)
1414 {
1415         struct netdev_private *np = netdev_priv(dev);
1416         int entry;
1417         int cnt = 0;
1418
1419         /* Refill the Rx ring buffers. */
1420         for (;(np->cur_rx - np->dirty_rx + RX_RING_SIZE) % RX_RING_SIZE > 0;
1421                 np->dirty_rx = (np->dirty_rx + 1) % RX_RING_SIZE) {
1422                 struct sk_buff *skb;
1423                 entry = np->dirty_rx % RX_RING_SIZE;
1424                 if (np->rx_skbuff[entry] == NULL) {
1425                         skb = netdev_alloc_skb(dev, np->rx_buf_sz + 2);
1426                         np->rx_skbuff[entry] = skb;
1427                         if (skb == NULL)
1428                                 break;          /* Better luck next round. */
1429                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1430                         np->rx_ring[entry].frag.addr = cpu_to_le32(
1431                                 dma_map_single(&np->pci_dev->dev, skb->data,
1432                                         np->rx_buf_sz, DMA_FROM_DEVICE));
1433                         if (dma_mapping_error(&np->pci_dev->dev,
1434                                     np->rx_ring[entry].frag.addr)) {
1435                             dev_kfree_skb_irq(skb);
1436                             np->rx_skbuff[entry] = NULL;
1437                             break;
1438                         }
1439                 }
1440                 /* Perhaps we need not reset this field. */
1441                 np->rx_ring[entry].frag.length =
1442                         cpu_to_le32(np->rx_buf_sz | LastFrag);
1443                 np->rx_ring[entry].status = 0;
1444                 cnt++;
1445         }
1446 }
1447 static void netdev_error(struct net_device *dev, int intr_status)
1448 {
1449         struct netdev_private *np = netdev_priv(dev);
1450         void __iomem *ioaddr = np->base;
1451         u16 mii_ctl, mii_advertise, mii_lpa;
1452         int speed;
1453
1454         if (intr_status & LinkChange) {
1455                 if (mdio_wait_link(dev, 10) == 0) {
1456                         printk(KERN_INFO "%s: Link up\n", dev->name);
1457                         if (np->an_enable) {
1458                                 mii_advertise = mdio_read(dev, np->phys[0],
1459                                                            MII_ADVERTISE);
1460                                 mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
1461                                 mii_advertise &= mii_lpa;
1462                                 printk(KERN_INFO "%s: Link changed: ",
1463                                         dev->name);
1464                                 if (mii_advertise & ADVERTISE_100FULL) {
1465                                         np->speed = 100;
1466                                         printk("100Mbps, full duplex\n");
1467                                 } else if (mii_advertise & ADVERTISE_100HALF) {
1468                                         np->speed = 100;
1469                                         printk("100Mbps, half duplex\n");
1470                                 } else if (mii_advertise & ADVERTISE_10FULL) {
1471                                         np->speed = 10;
1472                                         printk("10Mbps, full duplex\n");
1473                                 } else if (mii_advertise & ADVERTISE_10HALF) {
1474                                         np->speed = 10;
1475                                         printk("10Mbps, half duplex\n");
1476                                 } else
1477                                         printk("\n");
1478
1479                         } else {
1480                                 mii_ctl = mdio_read(dev, np->phys[0], MII_BMCR);
1481                                 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
1482                                 np->speed = speed;
1483                                 printk(KERN_INFO "%s: Link changed: %dMbps ,",
1484                                         dev->name, speed);
1485                                 printk("%s duplex.\n",
1486                                         (mii_ctl & BMCR_FULLDPLX) ?
1487                                                 "full" : "half");
1488                         }
1489                         check_duplex(dev);
1490                         if (np->flowctrl && np->mii_if.full_duplex) {
1491                                 iowrite16(ioread16(ioaddr + MulticastFilter1+2) | 0x0200,
1492                                         ioaddr + MulticastFilter1+2);
1493                                 iowrite16(ioread16(ioaddr + MACCtrl0) | EnbFlowCtrl,
1494                                         ioaddr + MACCtrl0);
1495                         }
1496                         netif_carrier_on(dev);
1497                 } else {
1498                         printk(KERN_INFO "%s: Link down\n", dev->name);
1499                         netif_carrier_off(dev);
1500                 }
1501         }
1502         if (intr_status & StatsMax) {
1503                 get_stats(dev);
1504         }
1505         if (intr_status & IntrPCIErr) {
1506                 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1507                            dev->name, intr_status);
1508                 /* We must do a global reset of DMA to continue. */
1509         }
1510 }
1511
1512 static struct net_device_stats *get_stats(struct net_device *dev)
1513 {
1514         struct netdev_private *np = netdev_priv(dev);
1515         void __iomem *ioaddr = np->base;
1516         unsigned long flags;
1517         u8 late_coll, single_coll, mult_coll;
1518
1519         spin_lock_irqsave(&np->statlock, flags);
1520         /* The chip only need report frame silently dropped. */
1521         dev->stats.rx_missed_errors     += ioread8(ioaddr + RxMissed);
1522         dev->stats.tx_packets += ioread16(ioaddr + TxFramesOK);
1523         dev->stats.rx_packets += ioread16(ioaddr + RxFramesOK);
1524         dev->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);
1525
1526         mult_coll = ioread8(ioaddr + StatsMultiColl);
1527         np->xstats.tx_multiple_collisions += mult_coll;
1528         single_coll = ioread8(ioaddr + StatsOneColl);
1529         np->xstats.tx_single_collisions += single_coll;
1530         late_coll = ioread8(ioaddr + StatsLateColl);
1531         np->xstats.tx_late_collisions += late_coll;
1532         dev->stats.collisions += mult_coll
1533                 + single_coll
1534                 + late_coll;
1535
1536         np->xstats.tx_deferred += ioread8(ioaddr + StatsTxDefer);
1537         np->xstats.tx_deferred_excessive += ioread8(ioaddr + StatsTxXSDefer);
1538         np->xstats.tx_aborted += ioread8(ioaddr + StatsTxAbort);
1539         np->xstats.tx_bcasts += ioread8(ioaddr + StatsBcastTx);
1540         np->xstats.rx_bcasts += ioread8(ioaddr + StatsBcastRx);
1541         np->xstats.tx_mcasts += ioread8(ioaddr + StatsMcastTx);
1542         np->xstats.rx_mcasts += ioread8(ioaddr + StatsMcastRx);
1543
1544         dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsLow);
1545         dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsHigh) << 16;
1546         dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsLow);
1547         dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsHigh) << 16;
1548
1549         spin_unlock_irqrestore(&np->statlock, flags);
1550
1551         return &dev->stats;
1552 }
1553
1554 static void set_rx_mode(struct net_device *dev)
1555 {
1556         struct netdev_private *np = netdev_priv(dev);
1557         void __iomem *ioaddr = np->base;
1558         u16 mc_filter[4];                       /* Multicast hash filter */
1559         u32 rx_mode;
1560         int i;
1561
1562         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1563                 memset(mc_filter, 0xff, sizeof(mc_filter));
1564                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys;
1565         } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1566                    (dev->flags & IFF_ALLMULTI)) {
1567                 /* Too many to match, or accept all multicasts. */
1568                 memset(mc_filter, 0xff, sizeof(mc_filter));
1569                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1570         } else if (!netdev_mc_empty(dev)) {
1571                 struct netdev_hw_addr *ha;
1572                 int bit;
1573                 int index;
1574                 int crc;
1575                 memset (mc_filter, 0, sizeof (mc_filter));
1576                 netdev_for_each_mc_addr(ha, dev) {
1577                         crc = ether_crc_le(ETH_ALEN, ha->addr);
1578                         for (index=0, bit=0; bit < 6; bit++, crc <<= 1)
1579                                 if (crc & 0x80000000) index |= 1 << bit;
1580                         mc_filter[index/16] |= (1 << (index % 16));
1581                 }
1582                 rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys;
1583         } else {
1584                 iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1585                 return;
1586         }
1587         if (np->mii_if.full_duplex && np->flowctrl)
1588                 mc_filter[3] |= 0x0200;
1589
1590         for (i = 0; i < 4; i++)
1591                 iowrite16(mc_filter[i], ioaddr + MulticastFilter0 + i*2);
1592         iowrite8(rx_mode, ioaddr + RxMode);
1593 }
1594
1595 static int __set_mac_addr(struct net_device *dev)
1596 {
1597         struct netdev_private *np = netdev_priv(dev);
1598         u16 addr16;
1599
1600         addr16 = (dev->dev_addr[0] | (dev->dev_addr[1] << 8));
1601         iowrite16(addr16, np->base + StationAddr);
1602         addr16 = (dev->dev_addr[2] | (dev->dev_addr[3] << 8));
1603         iowrite16(addr16, np->base + StationAddr+2);
1604         addr16 = (dev->dev_addr[4] | (dev->dev_addr[5] << 8));
1605         iowrite16(addr16, np->base + StationAddr+4);
1606         return 0;
1607 }
1608
1609 /* Invoked with rtnl_lock held */
1610 static int sundance_set_mac_addr(struct net_device *dev, void *data)
1611 {
1612         const struct sockaddr *addr = data;
1613
1614         if (!is_valid_ether_addr(addr->sa_data))
1615                 return -EADDRNOTAVAIL;
1616         eth_hw_addr_set(dev, addr->sa_data);
1617         __set_mac_addr(dev);
1618
1619         return 0;
1620 }
1621
1622 static const struct {
1623         const char name[ETH_GSTRING_LEN];
1624 } sundance_stats[] = {
1625         { "tx_multiple_collisions" },
1626         { "tx_single_collisions" },
1627         { "tx_late_collisions" },
1628         { "tx_deferred" },
1629         { "tx_deferred_excessive" },
1630         { "tx_aborted" },
1631         { "tx_bcasts" },
1632         { "rx_bcasts" },
1633         { "tx_mcasts" },
1634         { "rx_mcasts" },
1635 };
1636
1637 static int check_if_running(struct net_device *dev)
1638 {
1639         if (!netif_running(dev))
1640                 return -EINVAL;
1641         return 0;
1642 }
1643
1644 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1645 {
1646         struct netdev_private *np = netdev_priv(dev);
1647         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1648         strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1649 }
1650
1651 static int get_link_ksettings(struct net_device *dev,
1652                               struct ethtool_link_ksettings *cmd)
1653 {
1654         struct netdev_private *np = netdev_priv(dev);
1655         spin_lock_irq(&np->lock);
1656         mii_ethtool_get_link_ksettings(&np->mii_if, cmd);
1657         spin_unlock_irq(&np->lock);
1658         return 0;
1659 }
1660
1661 static int set_link_ksettings(struct net_device *dev,
1662                               const struct ethtool_link_ksettings *cmd)
1663 {
1664         struct netdev_private *np = netdev_priv(dev);
1665         int res;
1666         spin_lock_irq(&np->lock);
1667         res = mii_ethtool_set_link_ksettings(&np->mii_if, cmd);
1668         spin_unlock_irq(&np->lock);
1669         return res;
1670 }
1671
1672 static int nway_reset(struct net_device *dev)
1673 {
1674         struct netdev_private *np = netdev_priv(dev);
1675         return mii_nway_restart(&np->mii_if);
1676 }
1677
1678 static u32 get_link(struct net_device *dev)
1679 {
1680         struct netdev_private *np = netdev_priv(dev);
1681         return mii_link_ok(&np->mii_if);
1682 }
1683
1684 static u32 get_msglevel(struct net_device *dev)
1685 {
1686         struct netdev_private *np = netdev_priv(dev);
1687         return np->msg_enable;
1688 }
1689
1690 static void set_msglevel(struct net_device *dev, u32 val)
1691 {
1692         struct netdev_private *np = netdev_priv(dev);
1693         np->msg_enable = val;
1694 }
1695
1696 static void get_strings(struct net_device *dev, u32 stringset,
1697                 u8 *data)
1698 {
1699         if (stringset == ETH_SS_STATS)
1700                 memcpy(data, sundance_stats, sizeof(sundance_stats));
1701 }
1702
1703 static int get_sset_count(struct net_device *dev, int sset)
1704 {
1705         switch (sset) {
1706         case ETH_SS_STATS:
1707                 return ARRAY_SIZE(sundance_stats);
1708         default:
1709                 return -EOPNOTSUPP;
1710         }
1711 }
1712
1713 static void get_ethtool_stats(struct net_device *dev,
1714                 struct ethtool_stats *stats, u64 *data)
1715 {
1716         struct netdev_private *np = netdev_priv(dev);
1717         int i = 0;
1718
1719         get_stats(dev);
1720         data[i++] = np->xstats.tx_multiple_collisions;
1721         data[i++] = np->xstats.tx_single_collisions;
1722         data[i++] = np->xstats.tx_late_collisions;
1723         data[i++] = np->xstats.tx_deferred;
1724         data[i++] = np->xstats.tx_deferred_excessive;
1725         data[i++] = np->xstats.tx_aborted;
1726         data[i++] = np->xstats.tx_bcasts;
1727         data[i++] = np->xstats.rx_bcasts;
1728         data[i++] = np->xstats.tx_mcasts;
1729         data[i++] = np->xstats.rx_mcasts;
1730 }
1731
1732 #ifdef CONFIG_PM
1733
1734 static void sundance_get_wol(struct net_device *dev,
1735                 struct ethtool_wolinfo *wol)
1736 {
1737         struct netdev_private *np = netdev_priv(dev);
1738         void __iomem *ioaddr = np->base;
1739         u8 wol_bits;
1740
1741         wol->wolopts = 0;
1742
1743         wol->supported = (WAKE_PHY | WAKE_MAGIC);
1744         if (!np->wol_enabled)
1745                 return;
1746
1747         wol_bits = ioread8(ioaddr + WakeEvent);
1748         if (wol_bits & MagicPktEnable)
1749                 wol->wolopts |= WAKE_MAGIC;
1750         if (wol_bits & LinkEventEnable)
1751                 wol->wolopts |= WAKE_PHY;
1752 }
1753
1754 static int sundance_set_wol(struct net_device *dev,
1755         struct ethtool_wolinfo *wol)
1756 {
1757         struct netdev_private *np = netdev_priv(dev);
1758         void __iomem *ioaddr = np->base;
1759         u8 wol_bits;
1760
1761         if (!device_can_wakeup(&np->pci_dev->dev))
1762                 return -EOPNOTSUPP;
1763
1764         np->wol_enabled = !!(wol->wolopts);
1765         wol_bits = ioread8(ioaddr + WakeEvent);
1766         wol_bits &= ~(WakePktEnable | MagicPktEnable |
1767                         LinkEventEnable | WolEnable);
1768
1769         if (np->wol_enabled) {
1770                 if (wol->wolopts & WAKE_MAGIC)
1771                         wol_bits |= (MagicPktEnable | WolEnable);
1772                 if (wol->wolopts & WAKE_PHY)
1773                         wol_bits |= (LinkEventEnable | WolEnable);
1774         }
1775         iowrite8(wol_bits, ioaddr + WakeEvent);
1776
1777         device_set_wakeup_enable(&np->pci_dev->dev, np->wol_enabled);
1778
1779         return 0;
1780 }
1781 #else
1782 #define sundance_get_wol NULL
1783 #define sundance_set_wol NULL
1784 #endif /* CONFIG_PM */
1785
1786 static const struct ethtool_ops ethtool_ops = {
1787         .begin = check_if_running,
1788         .get_drvinfo = get_drvinfo,
1789         .nway_reset = nway_reset,
1790         .get_link = get_link,
1791         .get_wol = sundance_get_wol,
1792         .set_wol = sundance_set_wol,
1793         .get_msglevel = get_msglevel,
1794         .set_msglevel = set_msglevel,
1795         .get_strings = get_strings,
1796         .get_sset_count = get_sset_count,
1797         .get_ethtool_stats = get_ethtool_stats,
1798         .get_link_ksettings = get_link_ksettings,
1799         .set_link_ksettings = set_link_ksettings,
1800 };
1801
1802 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1803 {
1804         struct netdev_private *np = netdev_priv(dev);
1805         int rc;
1806
1807         if (!netif_running(dev))
1808                 return -EINVAL;
1809
1810         spin_lock_irq(&np->lock);
1811         rc = generic_mii_ioctl(&np->mii_if, if_mii(rq), cmd, NULL);
1812         spin_unlock_irq(&np->lock);
1813
1814         return rc;
1815 }
1816
1817 static int netdev_close(struct net_device *dev)
1818 {
1819         struct netdev_private *np = netdev_priv(dev);
1820         void __iomem *ioaddr = np->base;
1821         struct sk_buff *skb;
1822         int i;
1823
1824         /* Wait and kill tasklet */
1825         tasklet_kill(&np->rx_tasklet);
1826         tasklet_kill(&np->tx_tasklet);
1827         np->cur_tx = 0;
1828         np->dirty_tx = 0;
1829         np->cur_task = 0;
1830         np->last_tx = NULL;
1831
1832         netif_stop_queue(dev);
1833
1834         if (netif_msg_ifdown(np)) {
1835                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x "
1836                            "Rx %4.4x Int %2.2x.\n",
1837                            dev->name, ioread8(ioaddr + TxStatus),
1838                            ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));
1839                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
1840                            dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
1841         }
1842
1843         /* Disable interrupts by clearing the interrupt mask. */
1844         iowrite16(0x0000, ioaddr + IntrEnable);
1845
1846         /* Disable Rx and Tx DMA for safely release resource */
1847         iowrite32(0x500, ioaddr + DMACtrl);
1848
1849         /* Stop the chip's Tx and Rx processes. */
1850         iowrite16(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1);
1851
1852         for (i = 2000; i > 0; i--) {
1853                 if ((ioread32(ioaddr + DMACtrl) & 0xc000) == 0)
1854                         break;
1855                 mdelay(1);
1856         }
1857
1858         iowrite16(GlobalReset | DMAReset | FIFOReset | NetworkReset,
1859                         ioaddr + ASIC_HI_WORD(ASICCtrl));
1860
1861         for (i = 2000; i > 0; i--) {
1862                 if ((ioread16(ioaddr + ASIC_HI_WORD(ASICCtrl)) & ResetBusy) == 0)
1863                         break;
1864                 mdelay(1);
1865         }
1866
1867 #ifdef __i386__
1868         if (netif_msg_hw(np)) {
1869                 printk(KERN_DEBUG "  Tx ring at %8.8x:\n",
1870                            (int)(np->tx_ring_dma));
1871                 for (i = 0; i < TX_RING_SIZE; i++)
1872                         printk(KERN_DEBUG " #%d desc. %4.4x %8.8x %8.8x.\n",
1873                                    i, np->tx_ring[i].status, np->tx_ring[i].frag.addr,
1874                                    np->tx_ring[i].frag.length);
1875                 printk(KERN_DEBUG "  Rx ring %8.8x:\n",
1876                            (int)(np->rx_ring_dma));
1877                 for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
1878                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
1879                                    i, np->rx_ring[i].status, np->rx_ring[i].frag.addr,
1880                                    np->rx_ring[i].frag.length);
1881                 }
1882         }
1883 #endif /* __i386__ debugging only */
1884
1885         free_irq(np->pci_dev->irq, dev);
1886
1887         del_timer_sync(&np->timer);
1888
1889         /* Free all the skbuffs in the Rx queue. */
1890         for (i = 0; i < RX_RING_SIZE; i++) {
1891                 np->rx_ring[i].status = 0;
1892                 skb = np->rx_skbuff[i];
1893                 if (skb) {
1894                         dma_unmap_single(&np->pci_dev->dev,
1895                                 le32_to_cpu(np->rx_ring[i].frag.addr),
1896                                 np->rx_buf_sz, DMA_FROM_DEVICE);
1897                         dev_kfree_skb(skb);
1898                         np->rx_skbuff[i] = NULL;
1899                 }
1900                 np->rx_ring[i].frag.addr = cpu_to_le32(0xBADF00D0); /* poison */
1901         }
1902         for (i = 0; i < TX_RING_SIZE; i++) {
1903                 np->tx_ring[i].next_desc = 0;
1904                 skb = np->tx_skbuff[i];
1905                 if (skb) {
1906                         dma_unmap_single(&np->pci_dev->dev,
1907                                 le32_to_cpu(np->tx_ring[i].frag.addr),
1908                                 skb->len, DMA_TO_DEVICE);
1909                         dev_kfree_skb(skb);
1910                         np->tx_skbuff[i] = NULL;
1911                 }
1912         }
1913
1914         return 0;
1915 }
1916
1917 static void sundance_remove1(struct pci_dev *pdev)
1918 {
1919         struct net_device *dev = pci_get_drvdata(pdev);
1920
1921         if (dev) {
1922             struct netdev_private *np = netdev_priv(dev);
1923             unregister_netdev(dev);
1924             dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
1925                     np->rx_ring, np->rx_ring_dma);
1926             dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
1927                     np->tx_ring, np->tx_ring_dma);
1928             pci_iounmap(pdev, np->base);
1929             pci_release_regions(pdev);
1930             free_netdev(dev);
1931         }
1932 }
1933
1934 static int __maybe_unused sundance_suspend(struct device *dev_d)
1935 {
1936         struct net_device *dev = dev_get_drvdata(dev_d);
1937         struct netdev_private *np = netdev_priv(dev);
1938         void __iomem *ioaddr = np->base;
1939
1940         if (!netif_running(dev))
1941                 return 0;
1942
1943         netdev_close(dev);
1944         netif_device_detach(dev);
1945
1946         if (np->wol_enabled) {
1947                 iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1948                 iowrite16(RxEnable, ioaddr + MACCtrl1);
1949         }
1950
1951         device_set_wakeup_enable(dev_d, np->wol_enabled);
1952
1953         return 0;
1954 }
1955
1956 static int __maybe_unused sundance_resume(struct device *dev_d)
1957 {
1958         struct net_device *dev = dev_get_drvdata(dev_d);
1959         int err = 0;
1960
1961         if (!netif_running(dev))
1962                 return 0;
1963
1964         err = netdev_open(dev);
1965         if (err) {
1966                 printk(KERN_ERR "%s: Can't resume interface!\n",
1967                                 dev->name);
1968                 goto out;
1969         }
1970
1971         netif_device_attach(dev);
1972
1973 out:
1974         return err;
1975 }
1976
1977 static SIMPLE_DEV_PM_OPS(sundance_pm_ops, sundance_suspend, sundance_resume);
1978
1979 static struct pci_driver sundance_driver = {
1980         .name           = DRV_NAME,
1981         .id_table       = sundance_pci_tbl,
1982         .probe          = sundance_probe1,
1983         .remove         = sundance_remove1,
1984         .driver.pm      = &sundance_pm_ops,
1985 };
1986
1987 module_pci_driver(sundance_driver);