drivers/net/tulip/tulip_core.c

   1 /*      tulip_core.c: A DEC 21x4x-family ethernet driver for Linux.
   2
   3         Copyright 2000,2001  The Linux Kernel Team
   4         Written/copyright 1994-2001 by Donald Becker.
   5
   6         This software may be used and distributed according to the terms
   7         of the GNU General Public License, incorporated herein by reference.
   8
   9         Please refer to Documentation/DocBook/tulip-user.{pdf,ps,html}
  10         for more information on this driver.
  11
  12         Please submit bugs to http://bugzilla.kernel.org/ .
  13 */
  14
  15
  16 #define DRV_NAME        "tulip"
  17 #ifdef CONFIG_TULIP_NAPI
  18 #define DRV_VERSION    "1.1.15-NAPI" /* Keep at least for test */
  19 #else
  20 #define DRV_VERSION     "1.1.15"
  21 #endif
  22 #define DRV_RELDATE     "Feb 27, 2007"
  23
  24
  25 #include <linux/module.h>
  26 #include <linux/pci.h>
  27 #include "tulip.h"
  28 #include <linux/init.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/delay.h>
  31 #include <linux/mii.h>
  32 #include <linux/ethtool.h>
  33 #include <linux/crc32.h>
  34 #include <asm/unaligned.h>
  35 #include <asm/uaccess.h>
  36
  37 #ifdef CONFIG_SPARC
  38 #include <asm/prom.h>
  39 #endif
  40
  41 static char version[] __devinitdata =
  42         "Linux Tulip driver version " DRV_VERSION " (" DRV_RELDATE ")\n";
  43
  44
  45 /* A few user-configurable values. */
  46
  47 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  48 static unsigned int max_interrupt_work = 25;
  49
  50 #define MAX_UNITS 8
  51 /* Used to pass the full-duplex flag, etc. */
  52 static int full_duplex[MAX_UNITS];
  53 static int options[MAX_UNITS];
  54 static int mtu[MAX_UNITS];                      /* Jumbo MTU for interfaces. */
  55
  56 /*  The possible media types that can be set in options[] are: */
  57 const char * const medianame[32] = {
  58         "10baseT", "10base2", "AUI", "100baseTx",
  59         "10baseT-FDX", "100baseTx-FDX", "100baseT4", "100baseFx",
  60         "100baseFx-FDX", "MII 10baseT", "MII 10baseT-FDX", "MII",
  61         "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FDX", "MII 100baseT4",
  62         "MII 100baseFx-HDX", "MII 100baseFx-FDX", "Home-PNA 1Mbps", "Invalid-19",
  63         "","","","", "","","","",  "","","","Transceiver reset",
  64 };
  65
  66 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
  67 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
  68         || defined(CONFIG_SPARC) || defined(__ia64__) \
  69         || defined(__sh__) || defined(__mips__)
  70 static int rx_copybreak = 1518;
  71 #else
  72 static int rx_copybreak = 100;
  73 #endif
  74
  75 /*
  76   Set the bus performance register.
  77         Typical: Set 16 longword cache alignment, no burst limit.
  78         Cache alignment bits 15:14           Burst length 13:8
  79                 0000    No alignment  0x00000000 unlimited              0800 8 longwords
  80                 4000    8  longwords            0100 1 longword         1000 16 longwords
  81                 8000    16 longwords            0200 2 longwords        2000 32 longwords
  82                 C000    32  longwords           0400 4 longwords
  83         Warning: many older 486 systems are broken and require setting 0x00A04800
  84            8 longword cache alignment, 8 longword burst.
  85         ToDo: Non-Intel setting could be better.
  86 */
  87
  88 #if defined(__alpha__) || defined(__ia64__)
  89 static int csr0 = 0x01A00000 | 0xE000;
  90 #elif defined(__i386__) || defined(__powerpc__) || defined(__x86_64__)
  91 static int csr0 = 0x01A00000 | 0x8000;
  92 #elif defined(CONFIG_SPARC) || defined(__hppa__)
  93 /* The UltraSparc PCI controllers will disconnect at every 64-byte
  94  * crossing anyways so it makes no sense to tell Tulip to burst
  95  * any more than that.
  96  */
  97 static int csr0 = 0x01A00000 | 0x9000;
  98 #elif defined(__arm__) || defined(__sh__)
  99 static int csr0 = 0x01A00000 | 0x4800;
 100 #elif defined(__mips__)
 101 static int csr0 = 0x00200000 | 0x4000;
 102 #else
 103 #warning Processor architecture undefined!
 104 static int csr0 = 0x00A00000 | 0x4800;
 105 #endif
 106
 107 /* Operational parameters that usually are not changed. */
 108 /* Time in jiffies before concluding the transmitter is hung. */
 109 #define TX_TIMEOUT  (4*HZ)
 110
 111
 112 MODULE_AUTHOR("The Linux Kernel Team");
 113 MODULE_DESCRIPTION("Digital 21*4* Tulip ethernet driver");
 114 MODULE_LICENSE("GPL");
 115 MODULE_VERSION(DRV_VERSION);
 116 module_param(tulip_debug, int, 0);
 117 module_param(max_interrupt_work, int, 0);
 118 module_param(rx_copybreak, int, 0);
 119 module_param(csr0, int, 0);
 120 module_param_array(options, int, NULL, 0);
 121 module_param_array(full_duplex, int, NULL, 0);
 122
 123 #define PFX DRV_NAME ": "
 124
 125 #ifdef TULIP_DEBUG
 126 int tulip_debug = TULIP_DEBUG;
 127 #else
 128 int tulip_debug = 1;
 129 #endif
 130
 131 static void tulip_timer(unsigned long data)
 132 {
 133         struct net_device *dev = (struct net_device *)data;
 134         struct tulip_private *tp = netdev_priv(dev);
 135
 136         if (netif_running(dev))
 137                 schedule_work(&tp->media_work);
 138 }
 139
 140 /*
 141  * This table use during operation for capabilities and media timer.
 142  *
 143  * It is indexed via the values in 'enum chips'
 144  */
 145
 146 struct tulip_chip_table tulip_tbl[] = {
 147   { }, /* placeholder for array, slot unused currently */
 148   { }, /* placeholder for array, slot unused currently */
 149
 150   /* DC21140 */
 151   { "Digital DS21140 Tulip", 128, 0x0001ebef,
 152         HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | HAS_PCI_MWI, tulip_timer,
 153         tulip_media_task },
 154
 155   /* DC21142, DC21143 */
 156   { "Digital DS21142/43 Tulip", 128, 0x0801fbff,
 157         HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_ACPI | HAS_NWAY
 158         | HAS_INTR_MITIGATION | HAS_PCI_MWI, tulip_timer, t21142_media_task },
 159
 160   /* LC82C168 */
 161   { "Lite-On 82c168 PNIC", 256, 0x0001fbef,
 162         HAS_MII | HAS_PNICNWAY, pnic_timer, },
 163
 164   /* MX98713 */
 165   { "Macronix 98713 PMAC", 128, 0x0001ebef,
 166         HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, mxic_timer, },
 167
 168   /* MX98715 */
 169   { "Macronix 98715 PMAC", 256, 0x0001ebef,
 170         HAS_MEDIA_TABLE, mxic_timer, },
 171
 172   /* MX98725 */
 173   { "Macronix 98725 PMAC", 256, 0x0001ebef,
 174         HAS_MEDIA_TABLE, mxic_timer, },
 175
 176   /* AX88140 */
 177   { "ASIX AX88140", 128, 0x0001fbff,
 178         HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | MC_HASH_ONLY
 179         | IS_ASIX, tulip_timer, tulip_media_task },
 180
 181   /* PNIC2 */
 182   { "Lite-On PNIC-II", 256, 0x0801fbff,
 183         HAS_MII | HAS_NWAY | HAS_8023X | HAS_PCI_MWI, pnic2_timer, },
 184
 185   /* COMET */
 186   { "ADMtek Comet", 256, 0x0001abef,
 187         HAS_MII | MC_HASH_ONLY | COMET_MAC_ADDR, comet_timer, },
 188
 189   /* COMPEX9881 */
 190   { "Compex 9881 PMAC", 128, 0x0001ebef,
 191         HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, mxic_timer, },
 192
 193   /* I21145 */
 194   { "Intel DS21145 Tulip", 128, 0x0801fbff,
 195         HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_ACPI
 196         | HAS_NWAY | HAS_PCI_MWI, tulip_timer, tulip_media_task },
 197
 198   /* DM910X */
 199   { "Davicom DM9102/DM9102A", 128, 0x0001ebef,
 200         HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | HAS_ACPI,
 201         tulip_timer, tulip_media_task },
 202
 203   /* RS7112 */
 204   { "Conexant LANfinity", 256, 0x0001ebef,
 205         HAS_MII | HAS_ACPI, tulip_timer, tulip_media_task },
 206
 207 };
 208
 209
 210 static struct pci_device_id tulip_pci_tbl[] = {
 211         { 0x1011, 0x0009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21140 },
 212         { 0x1011, 0x0019, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21143 },
 213         { 0x11AD, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, LC82C168 },
 214         { 0x10d9, 0x0512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98713 },
 215         { 0x10d9, 0x0531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98715 },
 216 /*      { 0x10d9, 0x0531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98725 },*/
 217         { 0x125B, 0x1400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AX88140 },
 218         { 0x11AD, 0xc115, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PNIC2 },
 219         { 0x1317, 0x0981, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 220         { 0x1317, 0x0985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 221         { 0x1317, 0x1985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 222         { 0x1317, 0x9511, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 223         { 0x13D1, 0xAB02, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 224         { 0x13D1, 0xAB03, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 225         { 0x13D1, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 226         { 0x104A, 0x0981, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 227         { 0x104A, 0x2774, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 228         { 0x1259, 0xa120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 229         { 0x11F6, 0x9881, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMPEX9881 },
 230         { 0x8086, 0x0039, PCI_ANY_ID, PCI_ANY_ID, 0, 0, I21145 },
 231         { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
 232         { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
 233         { 0x1113, 0x1216, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 234         { 0x1113, 0x1217, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98715 },
 235         { 0x1113, 0x9511, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 236         { 0x1186, 0x1541, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 237         { 0x1186, 0x1561, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 238         { 0x1186, 0x1591, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 239         { 0x14f1, 0x1803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CONEXANT },
 240         { 0x1626, 0x8410, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 241         { 0x1737, 0xAB09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 242         { 0x1737, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 243         { 0x17B3, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 244         { 0x10b7, 0x9300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* 3Com 3CSOHO100B-TX */
 245         { 0x14ea, 0xab08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* Planex FNW-3602-TX */
 246         { 0x1414, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
 247         { } /* terminate list */
 248 };
 249 MODULE_DEVICE_TABLE(pci, tulip_pci_tbl);
 250
 251
 252 /* A full-duplex map for media types. */
 253 const char tulip_media_cap[32] =
 254 {0,0,0,16,  3,19,16,24,  27,4,7,5, 0,20,23,20,  28,31,0,0, };
 255
 256 static void tulip_tx_timeout(struct net_device *dev);
 257 static void tulip_init_ring(struct net_device *dev);
 258 static void tulip_free_ring(struct net_device *dev);
 259 static int tulip_start_xmit(struct sk_buff *skb, struct net_device *dev);
 260 static int tulip_open(struct net_device *dev);
 261 static int tulip_close(struct net_device *dev);
 262 static void tulip_up(struct net_device *dev);
 263 static void tulip_down(struct net_device *dev);
 264 static struct net_device_stats *tulip_get_stats(struct net_device *dev);
 265 static int private_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 266 static void set_rx_mode(struct net_device *dev);
 267 #ifdef CONFIG_NET_POLL_CONTROLLER
 268 static void poll_tulip(struct net_device *dev);
 269 #endif
 270
 271 static void tulip_set_power_state (struct tulip_private *tp,
 272                                    int sleep, int snooze)
 273 {
 274         if (tp->flags & HAS_ACPI) {
 275                 u32 tmp, newtmp;
 276                 pci_read_config_dword (tp->pdev, CFDD, &tmp);
 277                 newtmp = tmp & ~(CFDD_Sleep | CFDD_Snooze);
 278                 if (sleep)
 279                         newtmp |= CFDD_Sleep;
 280                 else if (snooze)
 281                         newtmp |= CFDD_Snooze;
 282                 if (tmp != newtmp)
 283                         pci_write_config_dword (tp->pdev, CFDD, newtmp);
 284         }
 285
 286 }
 287
 288
 289 static void tulip_up(struct net_device *dev)
 290 {
 291         struct tulip_private *tp = netdev_priv(dev);
 292         void __iomem *ioaddr = tp->base_addr;
 293         int next_tick = 3*HZ;
 294         u32 reg;
 295         int i;
 296
 297 #ifdef CONFIG_TULIP_NAPI
 298         napi_enable(&tp->napi);
 299 #endif
 300
 301         /* Wake the chip from sleep/snooze mode. */
 302         tulip_set_power_state (tp, 0, 0);
 303
 304         /* On some chip revs we must set the MII/SYM port before the reset!? */
 305         if (tp->mii_cnt  ||  (tp->mtable  &&  tp->mtable->has_mii))
 306                 iowrite32(0x00040000, ioaddr + CSR6);
 307
 308         /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
 309         iowrite32(0x00000001, ioaddr + CSR0);
 310         pci_read_config_dword(tp->pdev, PCI_COMMAND, &reg);  /* flush write */
 311         udelay(100);
 312
 313         /* Deassert reset.
 314            Wait the specified 50 PCI cycles after a reset by initializing
 315            Tx and Rx queues and the address filter list. */
 316         iowrite32(tp->csr0, ioaddr + CSR0);
 317         pci_read_config_dword(tp->pdev, PCI_COMMAND, &reg);  /* flush write */
 318         udelay(100);
 319
 320         if (tulip_debug > 1)
 321                 printk(KERN_DEBUG "%s: tulip_up(), irq==%d.\n", dev->name, dev->irq);
 322
 323         iowrite32(tp->rx_ring_dma, ioaddr + CSR3);
 324         iowrite32(tp->tx_ring_dma, ioaddr + CSR4);
 325         tp->cur_rx = tp->cur_tx = 0;
 326         tp->dirty_rx = tp->dirty_tx = 0;
 327
 328         if (tp->flags & MC_HASH_ONLY) {
 329                 u32 addr_low = get_unaligned_le32(dev->dev_addr);
 330                 u32 addr_high = get_unaligned_le16(dev->dev_addr + 4);
 331                 if (tp->chip_id == AX88140) {
 332                         iowrite32(0, ioaddr + CSR13);
 333                         iowrite32(addr_low,  ioaddr + CSR14);
 334                         iowrite32(1, ioaddr + CSR13);
 335                         iowrite32(addr_high, ioaddr + CSR14);
 336                 } else if (tp->flags & COMET_MAC_ADDR) {
 337                         iowrite32(addr_low,  ioaddr + 0xA4);
 338                         iowrite32(addr_high, ioaddr + 0xA8);
 339                         iowrite32(0, ioaddr + 0xAC);
 340                         iowrite32(0, ioaddr + 0xB0);
 341                 }
 342         } else {
 343                 /* This is set_rx_mode(), but without starting the transmitter. */
 344                 u16 *eaddrs = (u16 *)dev->dev_addr;
 345                 u16 *setup_frm = &tp->setup_frame[15*6];
 346                 dma_addr_t mapping;
 347
 348                 /* 21140 bug: you must add the broadcast address. */
 349                 memset(tp->setup_frame, 0xff, sizeof(tp->setup_frame));
 350                 /* Fill the final entry of the table with our physical address. */
 351                 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
 352                 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
 353                 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
 354
 355                 mapping = pci_map_single(tp->pdev, tp->setup_frame,
 356                                          sizeof(tp->setup_frame),
 357                                          PCI_DMA_TODEVICE);
 358                 tp->tx_buffers[tp->cur_tx].skb = NULL;
 359                 tp->tx_buffers[tp->cur_tx].mapping = mapping;
 360
 361                 /* Put the setup frame on the Tx list. */
 362                 tp->tx_ring[tp->cur_tx].length = cpu_to_le32(0x08000000 | 192);
 363                 tp->tx_ring[tp->cur_tx].buffer1 = cpu_to_le32(mapping);
 364                 tp->tx_ring[tp->cur_tx].status = cpu_to_le32(DescOwned);
 365
 366                 tp->cur_tx++;
 367         }
 368
 369         tp->saved_if_port = dev->if_port;
 370         if (dev->if_port == 0)
 371                 dev->if_port = tp->default_port;
 372
 373         /* Allow selecting a default media. */
 374         i = 0;
 375         if (tp->mtable == NULL)
 376                 goto media_picked;
 377         if (dev->if_port) {
 378                 int looking_for = tulip_media_cap[dev->if_port] & MediaIsMII ? 11 :
 379                         (dev->if_port == 12 ? 0 : dev->if_port);
 380                 for (i = 0; i < tp->mtable->leafcount; i++)
 381                         if (tp->mtable->mleaf[i].media == looking_for) {
 382                                 printk(KERN_INFO "%s: Using user-specified media %s.\n",
 383                                            dev->name, medianame[dev->if_port]);
 384                                 goto media_picked;
 385                         }
 386         }
 387         if ((tp->mtable->defaultmedia & 0x0800) == 0) {
 388                 int looking_for = tp->mtable->defaultmedia & MEDIA_MASK;
 389                 for (i = 0; i < tp->mtable->leafcount; i++)
 390                         if (tp->mtable->mleaf[i].media == looking_for) {
 391                                 printk(KERN_INFO "%s: Using EEPROM-set media %s.\n",
 392                                            dev->name, medianame[looking_for]);
 393                                 goto media_picked;
 394                         }
 395         }
 396         /* Start sensing first non-full-duplex media. */
 397         for (i = tp->mtable->leafcount - 1;
 398                  (tulip_media_cap[tp->mtable->mleaf[i].media] & MediaAlwaysFD) && i > 0; i--)
 399                 ;
 400 media_picked:
 401
 402         tp->csr6 = 0;
 403         tp->cur_index = i;
 404         tp->nwayset = 0;
 405
 406         if (dev->if_port) {
 407                 if (tp->chip_id == DC21143  &&
 408                     (tulip_media_cap[dev->if_port] & MediaIsMII)) {
 409                         /* We must reset the media CSRs when we force-select MII mode. */
 410                         iowrite32(0x0000, ioaddr + CSR13);
 411                         iowrite32(0x0000, ioaddr + CSR14);
 412                         iowrite32(0x0008, ioaddr + CSR15);
 413                 }
 414                 tulip_select_media(dev, 1);
 415         } else if (tp->chip_id == DC21142) {
 416                 if (tp->mii_cnt) {
 417                         tulip_select_media(dev, 1);
 418                         if (tulip_debug > 1)
 419                                 printk(KERN_INFO "%s: Using MII transceiver %d, status "
 420                                            "%4.4x.\n",
 421                                            dev->name, tp->phys[0], tulip_mdio_read(dev, tp->phys[0], 1));
 422                         iowrite32(csr6_mask_defstate, ioaddr + CSR6);
 423                         tp->csr6 = csr6_mask_hdcap;
 424                         dev->if_port = 11;
 425                         iowrite32(0x0000, ioaddr + CSR13);
 426                         iowrite32(0x0000, ioaddr + CSR14);
 427                 } else
 428                         t21142_start_nway(dev);
 429         } else if (tp->chip_id == PNIC2) {
 430                 /* for initial startup advertise 10/100 Full and Half */
 431                 tp->sym_advertise = 0x01E0;
 432                 /* enable autonegotiate end interrupt */
 433                 iowrite32(ioread32(ioaddr+CSR5)| 0x00008010, ioaddr + CSR5);
 434                 iowrite32(ioread32(ioaddr+CSR7)| 0x00008010, ioaddr + CSR7);
 435                 pnic2_start_nway(dev);
 436         } else if (tp->chip_id == LC82C168  &&  ! tp->medialock) {
 437                 if (tp->mii_cnt) {
 438                         dev->if_port = 11;
 439                         tp->csr6 = 0x814C0000 | (tp->full_duplex ? 0x0200 : 0);
 440                         iowrite32(0x0001, ioaddr + CSR15);
 441                 } else if (ioread32(ioaddr + CSR5) & TPLnkPass)
 442                         pnic_do_nway(dev);
 443                 else {
 444                         /* Start with 10mbps to do autonegotiation. */
 445                         iowrite32(0x32, ioaddr + CSR12);
 446                         tp->csr6 = 0x00420000;
 447                         iowrite32(0x0001B078, ioaddr + 0xB8);
 448                         iowrite32(0x0201B078, ioaddr + 0xB8);
 449                         next_tick = 1*HZ;
 450                 }
 451         } else if ((tp->chip_id == MX98713 || tp->chip_id == COMPEX9881)
 452                            && ! tp->medialock) {
 453                 dev->if_port = 0;
 454                 tp->csr6 = 0x01880000 | (tp->full_duplex ? 0x0200 : 0);
 455                 iowrite32(0x0f370000 | ioread16(ioaddr + 0x80), ioaddr + 0x80);
 456         } else if (tp->chip_id == MX98715 || tp->chip_id == MX98725) {
 457                 /* Provided by BOLO, Macronix - 12/10/1998. */
 458                 dev->if_port = 0;
 459                 tp->csr6 = 0x01a80200;
 460                 iowrite32(0x0f370000 | ioread16(ioaddr + 0x80), ioaddr + 0x80);
 461                 iowrite32(0x11000 | ioread16(ioaddr + 0xa0), ioaddr + 0xa0);
 462         } else if (tp->chip_id == COMET || tp->chip_id == CONEXANT) {
 463                 /* Enable automatic Tx underrun recovery. */
 464                 iowrite32(ioread32(ioaddr + 0x88) | 1, ioaddr + 0x88);
 465                 dev->if_port = tp->mii_cnt ? 11 : 0;
 466                 tp->csr6 = 0x00040000;
 467         } else if (tp->chip_id == AX88140) {
 468                 tp->csr6 = tp->mii_cnt ? 0x00040100 : 0x00000100;
 469         } else
 470                 tulip_select_media(dev, 1);
 471
 472         /* Start the chip's Tx to process setup frame. */
 473         tulip_stop_rxtx(tp);
 474         barrier();
 475         udelay(5);
 476         iowrite32(tp->csr6 | TxOn, ioaddr + CSR6);
 477
 478         /* Enable interrupts by setting the interrupt mask. */
 479         iowrite32(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR5);
 480         iowrite32(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7);
 481         tulip_start_rxtx(tp);
 482         iowrite32(0, ioaddr + CSR2);            /* Rx poll demand */
 483
 484         if (tulip_debug > 2) {
 485                 printk(KERN_DEBUG "%s: Done tulip_up(), CSR0 %8.8x, CSR5 %8.8x CSR6 %8.8x.\n",
 486                            dev->name, ioread32(ioaddr + CSR0), ioread32(ioaddr + CSR5),
 487                            ioread32(ioaddr + CSR6));
 488         }
 489
 490         /* Set the timer to switch to check for link beat and perhaps switch
 491            to an alternate media type. */
 492         tp->timer.expires = RUN_AT(next_tick);
 493         add_timer(&tp->timer);
 494 #ifdef CONFIG_TULIP_NAPI
 495         init_timer(&tp->oom_timer);
 496         tp->oom_timer.data = (unsigned long)dev;
 497         tp->oom_timer.function = oom_timer;
 498 #endif
 499 }
 500
 501 static int
 502 tulip_open(struct net_device *dev)
 503 {
 504         int retval;
 505
 506         tulip_init_ring (dev);
 507
 508         retval = request_irq(dev->irq, &tulip_interrupt, IRQF_SHARED, dev->name, dev);
 509         if (retval)
 510                 goto free_ring;
 511
 512         tulip_up (dev);
 513
 514         netif_start_queue (dev);
 515
 516         return 0;
 517
 518 free_ring:
 519         tulip_free_ring (dev);
 520         return retval;
 521 }
 522
 523
 524 static void tulip_tx_timeout(struct net_device *dev)
 525 {
 526         struct tulip_private *tp = netdev_priv(dev);
 527         void __iomem *ioaddr = tp->base_addr;
 528         unsigned long flags;
 529
 530         spin_lock_irqsave (&tp->lock, flags);
 531
 532         if (tulip_media_cap[dev->if_port] & MediaIsMII) {
 533                 /* Do nothing -- the media monitor should handle this. */
 534                 if (tulip_debug > 1)
 535                         printk(KERN_WARNING "%s: Transmit timeout using MII device.\n",
 536                                    dev->name);
 537         } else if (tp->chip_id == DC21140 || tp->chip_id == DC21142
 538                            || tp->chip_id == MX98713 || tp->chip_id == COMPEX9881
 539                            || tp->chip_id == DM910X) {
 540                 printk(KERN_WARNING "%s: 21140 transmit timed out, status %8.8x, "
 541                            "SIA %8.8x %8.8x %8.8x %8.8x, resetting...\n",
 542                            dev->name, ioread32(ioaddr + CSR5), ioread32(ioaddr + CSR12),
 543                            ioread32(ioaddr + CSR13), ioread32(ioaddr + CSR14), ioread32(ioaddr + CSR15));
 544                 tp->timeout_recovery = 1;
 545                 schedule_work(&tp->media_work);
 546                 goto out_unlock;
 547         } else if (tp->chip_id == PNIC2) {
 548                 printk(KERN_WARNING "%s: PNIC2 transmit timed out, status %8.8x, "
 549                        "CSR6/7 %8.8x / %8.8x CSR12 %8.8x, resetting...\n",
 550                        dev->name, (int)ioread32(ioaddr + CSR5), (int)ioread32(ioaddr + CSR6),
 551                        (int)ioread32(ioaddr + CSR7), (int)ioread32(ioaddr + CSR12));
 552         } else {
 553                 printk(KERN_WARNING "%s: Transmit timed out, status %8.8x, CSR12 "
 554                            "%8.8x, resetting...\n",
 555                            dev->name, ioread32(ioaddr + CSR5), ioread32(ioaddr + CSR12));
 556                 dev->if_port = 0;
 557         }
 558
 559 #if defined(way_too_many_messages)
 560         if (tulip_debug > 3) {
 561                 int i;
 562                 for (i = 0; i < RX_RING_SIZE; i++) {
 563                         u8 *buf = (u8 *)(tp->rx_ring[i].buffer1);
 564                         int j;
 565                         printk(KERN_DEBUG "%2d: %8.8x %8.8x %8.8x %8.8x  "
 566                                    "%2.2x %2.2x %2.2x.\n",
 567                                    i, (unsigned int)tp->rx_ring[i].status,
 568                                    (unsigned int)tp->rx_ring[i].length,
 569                                    (unsigned int)tp->rx_ring[i].buffer1,
 570                                    (unsigned int)tp->rx_ring[i].buffer2,
 571                                    buf[0], buf[1], buf[2]);
 572                         for (j = 0; buf[j] != 0xee && j < 1600; j++)
 573                                 if (j < 100)
 574                                         printk(KERN_CONT " %2.2x", buf[j]);
 575                         printk(KERN_CONT " j=%d.\n", j);
 576                 }
 577                 printk(KERN_DEBUG "  Rx ring %8.8x: ", (int)tp->rx_ring);
 578                 for (i = 0; i < RX_RING_SIZE; i++)
 579                         printk(KERN_CONT " %8.8x",
 580                                (unsigned int)tp->rx_ring[i].status);
 581                 printk(KERN_DEBUG "  Tx ring %8.8x: ", (int)tp->tx_ring);
 582                 for (i = 0; i < TX_RING_SIZE; i++)
 583                         printk(KERN_CONT " %8.8x", (unsigned int)tp->tx_ring[i].status);
 584                 printk(KERN_CONT "\n");
 585         }
 586 #endif
 587
 588         tulip_tx_timeout_complete(tp, ioaddr);
 589
 590 out_unlock:
 591         spin_unlock_irqrestore (&tp->lock, flags);
 592         dev->trans_start = jiffies;
 593         netif_wake_queue (dev);
 594 }
 595
 596
 597 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
 598 static void tulip_init_ring(struct net_device *dev)
 599 {
 600         struct tulip_private *tp = netdev_priv(dev);
 601         int i;
 602
 603         tp->susp_rx = 0;
 604         tp->ttimer = 0;
 605         tp->nir = 0;
 606
 607         for (i = 0; i < RX_RING_SIZE; i++) {
 608                 tp->rx_ring[i].status = 0x00000000;
 609                 tp->rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ);
 610                 tp->rx_ring[i].buffer2 = cpu_to_le32(tp->rx_ring_dma + sizeof(struct tulip_rx_desc) * (i + 1));
 611                 tp->rx_buffers[i].skb = NULL;
 612                 tp->rx_buffers[i].mapping = 0;
 613         }
 614         /* Mark the last entry as wrapping the ring. */
 615         tp->rx_ring[i-1].length = cpu_to_le32(PKT_BUF_SZ | DESC_RING_WRAP);
 616         tp->rx_ring[i-1].buffer2 = cpu_to_le32(tp->rx_ring_dma);
 617
 618         for (i = 0; i < RX_RING_SIZE; i++) {
 619                 dma_addr_t mapping;
 620
 621                 /* Note the receive buffer must be longword aligned.
 622                    dev_alloc_skb() provides 16 byte alignment.  But do *not*
 623                    use skb_reserve() to align the IP header! */
 624                 struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ);
 625                 tp->rx_buffers[i].skb = skb;
 626                 if (skb == NULL)
 627                         break;
 628                 mapping = pci_map_single(tp->pdev, skb->data,
 629                                          PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
 630                 tp->rx_buffers[i].mapping = mapping;
 631                 skb->dev = dev;                 /* Mark as being used by this device. */
 632                 tp->rx_ring[i].status = cpu_to_le32(DescOwned); /* Owned by Tulip chip */
 633                 tp->rx_ring[i].buffer1 = cpu_to_le32(mapping);
 634         }
 635         tp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 636
 637         /* The Tx buffer descriptor is filled in as needed, but we
 638            do need to clear the ownership bit. */
 639         for (i = 0; i < TX_RING_SIZE; i++) {
 640                 tp->tx_buffers[i].skb = NULL;
 641                 tp->tx_buffers[i].mapping = 0;
 642                 tp->tx_ring[i].status = 0x00000000;
 643                 tp->tx_ring[i].buffer2 = cpu_to_le32(tp->tx_ring_dma + sizeof(struct tulip_tx_desc) * (i + 1));
 644         }
 645         tp->tx_ring[i-1].buffer2 = cpu_to_le32(tp->tx_ring_dma);
 646 }
 647
 648 static int
 649 tulip_start_xmit(struct sk_buff *skb, struct net_device *dev)
 650 {
 651         struct tulip_private *tp = netdev_priv(dev);
 652         int entry;
 653         u32 flag;
 654         dma_addr_t mapping;
 655
 656         spin_lock_irq(&tp->lock);
 657
 658         /* Calculate the next Tx descriptor entry. */
 659         entry = tp->cur_tx % TX_RING_SIZE;
 660
 661         tp->tx_buffers[entry].skb = skb;
 662         mapping = pci_map_single(tp->pdev, skb->data,
 663                                  skb->len, PCI_DMA_TODEVICE);
 664         tp->tx_buffers[entry].mapping = mapping;
 665         tp->tx_ring[entry].buffer1 = cpu_to_le32(mapping);
 666
 667         if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE/2) {/* Typical path */
 668                 flag = 0x60000000; /* No interrupt */
 669         } else if (tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2) {
 670                 flag = 0xe0000000; /* Tx-done intr. */
 671         } else if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE - 2) {
 672                 flag = 0x60000000; /* No Tx-done intr. */
 673         } else {                /* Leave room for set_rx_mode() to fill entries. */
 674                 flag = 0xe0000000; /* Tx-done intr. */
 675                 netif_stop_queue(dev);
 676         }
 677         if (entry == TX_RING_SIZE-1)
 678                 flag = 0xe0000000 | DESC_RING_WRAP;
 679
 680         tp->tx_ring[entry].length = cpu_to_le32(skb->len | flag);
 681         /* if we were using Transmit Automatic Polling, we would need a
 682          * wmb() here. */
 683         tp->tx_ring[entry].status = cpu_to_le32(DescOwned);
 684         wmb();
 685
 686         tp->cur_tx++;
 687
 688         /* Trigger an immediate transmit demand. */
 689         iowrite32(0, tp->base_addr + CSR1);
 690
 691         spin_unlock_irq(&tp->lock);
 692
 693         dev->trans_start = jiffies;
 694
 695         return NETDEV_TX_OK;
 696 }
 697
 698 static void tulip_clean_tx_ring(struct tulip_private *tp)
 699 {
 700         unsigned int dirty_tx;
 701
 702         for (dirty_tx = tp->dirty_tx ; tp->cur_tx - dirty_tx > 0;
 703                 dirty_tx++) {
 704                 int entry = dirty_tx % TX_RING_SIZE;
 705                 int status = le32_to_cpu(tp->tx_ring[entry].status);
 706
 707                 if (status < 0) {
 708                         tp->stats.tx_errors++;  /* It wasn't Txed */
 709                         tp->tx_ring[entry].status = 0;
 710                 }
 711
 712                 /* Check for Tx filter setup frames. */
 713                 if (tp->tx_buffers[entry].skb == NULL) {
 714                         /* test because dummy frames not mapped */
 715                         if (tp->tx_buffers[entry].mapping)
 716                                 pci_unmap_single(tp->pdev,
 717                                         tp->tx_buffers[entry].mapping,
 718                                         sizeof(tp->setup_frame),
 719                                         PCI_DMA_TODEVICE);
 720                         continue;
 721                 }
 722
 723                 pci_unmap_single(tp->pdev, tp->tx_buffers[entry].mapping,
 724                                 tp->tx_buffers[entry].skb->len,
 725                                 PCI_DMA_TODEVICE);
 726
 727                 /* Free the original skb. */
 728                 dev_kfree_skb_irq(tp->tx_buffers[entry].skb);
 729                 tp->tx_buffers[entry].skb = NULL;
 730                 tp->tx_buffers[entry].mapping = 0;
 731         }
 732 }
 733
 734 static void tulip_down (struct net_device *dev)
 735 {
 736         struct tulip_private *tp = netdev_priv(dev);
 737         void __iomem *ioaddr = tp->base_addr;
 738         unsigned long flags;
 739
 740         cancel_work_sync(&tp->media_work);
 741
 742 #ifdef CONFIG_TULIP_NAPI
 743         napi_disable(&tp->napi);
 744 #endif
 745
 746         del_timer_sync (&tp->timer);
 747 #ifdef CONFIG_TULIP_NAPI
 748         del_timer_sync (&tp->oom_timer);
 749 #endif
 750         spin_lock_irqsave (&tp->lock, flags);
 751
 752         /* Disable interrupts by clearing the interrupt mask. */
 753         iowrite32 (0x00000000, ioaddr + CSR7);
 754
 755         /* Stop the Tx and Rx processes. */
 756         tulip_stop_rxtx(tp);
 757
 758         /* prepare receive buffers */
 759         tulip_refill_rx(dev);
 760
 761         /* release any unconsumed transmit buffers */
 762         tulip_clean_tx_ring(tp);
 763
 764         if (ioread32 (ioaddr + CSR6) != 0xffffffff)
 765                 tp->stats.rx_missed_errors += ioread32 (ioaddr + CSR8) & 0xffff;
 766
 767         spin_unlock_irqrestore (&tp->lock, flags);
 768
 769         init_timer(&tp->timer);
 770         tp->timer.data = (unsigned long)dev;
 771         tp->timer.function = tulip_tbl[tp->chip_id].media_timer;
 772
 773         dev->if_port = tp->saved_if_port;
 774
 775         /* Leave the driver in snooze, not sleep, mode. */
 776         tulip_set_power_state (tp, 0, 1);
 777 }
 778
 779 static void tulip_free_ring (struct net_device *dev)
 780 {
 781         struct tulip_private *tp = netdev_priv(dev);
 782         int i;
 783
 784         /* Free all the skbuffs in the Rx queue. */
 785         for (i = 0; i < RX_RING_SIZE; i++) {
 786                 struct sk_buff *skb = tp->rx_buffers[i].skb;
 787                 dma_addr_t mapping = tp->rx_buffers[i].mapping;
 788
 789                 tp->rx_buffers[i].skb = NULL;
 790                 tp->rx_buffers[i].mapping = 0;
 791
 792                 tp->rx_ring[i].status = 0;      /* Not owned by Tulip chip. */
 793                 tp->rx_ring[i].length = 0;
 794                 /* An invalid address. */
 795                 tp->rx_ring[i].buffer1 = cpu_to_le32(0xBADF00D0);
 796                 if (skb) {
 797                         pci_unmap_single(tp->pdev, mapping, PKT_BUF_SZ,
 798                                          PCI_DMA_FROMDEVICE);
 799                         dev_kfree_skb (skb);
 800                 }
 801         }
 802
 803         for (i = 0; i < TX_RING_SIZE; i++) {
 804                 struct sk_buff *skb = tp->tx_buffers[i].skb;
 805
 806                 if (skb != NULL) {
 807                         pci_unmap_single(tp->pdev, tp->tx_buffers[i].mapping,
 808                                          skb->len, PCI_DMA_TODEVICE);
 809                         dev_kfree_skb (skb);
 810                 }
 811                 tp->tx_buffers[i].skb = NULL;
 812                 tp->tx_buffers[i].mapping = 0;
 813         }
 814 }
 815
 816 static int tulip_close (struct net_device *dev)
 817 {
 818         struct tulip_private *tp = netdev_priv(dev);
 819         void __iomem *ioaddr = tp->base_addr;
 820
 821         netif_stop_queue (dev);
 822
 823         tulip_down (dev);
 824
 825         if (tulip_debug > 1)
 826                 printk (KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n",
 827                         dev->name, ioread32 (ioaddr + CSR5));
 828
 829         free_irq (dev->irq, dev);
 830
 831         tulip_free_ring (dev);
 832
 833         return 0;
 834 }
 835
 836 static struct net_device_stats *tulip_get_stats(struct net_device *dev)
 837 {
 838         struct tulip_private *tp = netdev_priv(dev);
 839         void __iomem *ioaddr = tp->base_addr;
 840
 841         if (netif_running(dev)) {
 842                 unsigned long flags;
 843
 844                 spin_lock_irqsave (&tp->lock, flags);
 845
 846                 tp->stats.rx_missed_errors += ioread32(ioaddr + CSR8) & 0xffff;
 847
 848                 spin_unlock_irqrestore(&tp->lock, flags);
 849         }
 850
 851         return &tp->stats;
 852 }
 853
 854
 855 static void tulip_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 856 {
 857         struct tulip_private *np = netdev_priv(dev);
 858         strcpy(info->driver, DRV_NAME);
 859         strcpy(info->version, DRV_VERSION);
 860         strcpy(info->bus_info, pci_name(np->pdev));
 861 }
 862
 863 static const struct ethtool_ops ops = {
 864         .get_drvinfo = tulip_get_drvinfo
 865 };
 866
 867 /* Provide ioctl() calls to examine the MII xcvr state. */
 868 static int private_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
 869 {
 870         struct tulip_private *tp = netdev_priv(dev);
 871         void __iomem *ioaddr = tp->base_addr;
 872         struct mii_ioctl_data *data = if_mii(rq);
 873         const unsigned int phy_idx = 0;
 874         int phy = tp->phys[phy_idx] & 0x1f;
 875         unsigned int regnum = data->reg_num;
 876
 877         switch (cmd) {
 878         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
 879                 if (tp->mii_cnt)
 880                         data->phy_id = phy;
 881                 else if (tp->flags & HAS_NWAY)
 882                         data->phy_id = 32;
 883                 else if (tp->chip_id == COMET)
 884                         data->phy_id = 1;
 885                 else
 886                         return -ENODEV;
 887
 888         case SIOCGMIIREG:               /* Read MII PHY register. */
 889                 if (data->phy_id == 32 && (tp->flags & HAS_NWAY)) {
 890                         int csr12 = ioread32 (ioaddr + CSR12);
 891                         int csr14 = ioread32 (ioaddr + CSR14);
 892                         switch (regnum) {
 893                         case 0:
 894                                 if (((csr14<<5) & 0x1000) ||
 895                                         (dev->if_port == 5 && tp->nwayset))
 896                                         data->val_out = 0x1000;
 897                                 else
 898                                         data->val_out = (tulip_media_cap[dev->if_port]&MediaIs100 ? 0x2000 : 0)
 899                                                 | (tulip_media_cap[dev->if_port]&MediaIsFD ? 0x0100 : 0);
 900                                 break;
 901                         case 1:
 902                                 data->val_out =
 903                                         0x1848 +
 904                                         ((csr12&0x7000) == 0x5000 ? 0x20 : 0) +
 905                                         ((csr12&0x06) == 6 ? 0 : 4);
 906                                 data->val_out |= 0x6048;
 907                                 break;
 908                         case 4:
 909                                 /* Advertised value, bogus 10baseTx-FD value from CSR6. */
 910                                 data->val_out =
 911                                         ((ioread32(ioaddr + CSR6) >> 3) & 0x0040) +
 912                                         ((csr14 >> 1) & 0x20) + 1;
 913                                 data->val_out |= ((csr14 >> 9) & 0x03C0);
 914                                 break;
 915                         case 5: data->val_out = tp->lpar; break;
 916                         default: data->val_out = 0; break;
 917                         }
 918                 } else {
 919                         data->val_out = tulip_mdio_read (dev, data->phy_id & 0x1f, regnum);
 920                 }
 921                 return 0;
 922
 923         case SIOCSMIIREG:               /* Write MII PHY register. */
 924                 if (!capable (CAP_NET_ADMIN))
 925                         return -EPERM;
 926                 if (regnum & ~0x1f)
 927                         return -EINVAL;
 928                 if (data->phy_id == phy) {
 929                         u16 value = data->val_in;
 930                         switch (regnum) {
 931                         case 0: /* Check for autonegotiation on or reset. */
 932                                 tp->full_duplex_lock = (value & 0x9000) ? 0 : 1;
 933                                 if (tp->full_duplex_lock)
 934                                         tp->full_duplex = (value & 0x0100) ? 1 : 0;
 935                                 break;
 936                         case 4:
 937                                 tp->advertising[phy_idx] =
 938                                 tp->mii_advertise = data->val_in;
 939                                 break;
 940                         }
 941                 }
 942                 if (data->phy_id == 32 && (tp->flags & HAS_NWAY)) {
 943                         u16 value = data->val_in;
 944                         if (regnum == 0) {
 945                           if ((value & 0x1200) == 0x1200) {
 946                             if (tp->chip_id == PNIC2) {
 947                                    pnic2_start_nway (dev);
 948                             } else {
 949                                    t21142_start_nway (dev);
 950                             }
 951                           }
 952                         } else if (regnum == 4)
 953                                 tp->sym_advertise = value;
 954                 } else {
 955                         tulip_mdio_write (dev, data->phy_id & 0x1f, regnum, data->val_in);
 956                 }
 957                 return 0;
 958         default:
 959                 return -EOPNOTSUPP;
 960         }
 961
 962         return -EOPNOTSUPP;
 963 }
 964
 965
 966 /* Set or clear the multicast filter for this adaptor.
 967    Note that we only use exclusion around actually queueing the
 968    new frame, not around filling tp->setup_frame.  This is non-deterministic
 969    when re-entered but still correct. */
 970
 971 #undef set_bit_le
 972 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
 973
 974 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
 975 {
 976         struct tulip_private *tp = netdev_priv(dev);
 977         u16 hash_table[32];
 978         struct dev_mc_list *mclist;
 979         int i;
 980         u16 *eaddrs;
 981
 982         memset(hash_table, 0, sizeof(hash_table));
 983         set_bit_le(255, hash_table);                    /* Broadcast entry */
 984         /* This should work on big-endian machines as well. */
 985         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 986              i++, mclist = mclist->next) {
 987                 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
 988
 989                 set_bit_le(index, hash_table);
 990
 991         }
 992         for (i = 0; i < 32; i++) {
 993                 *setup_frm++ = hash_table[i];
 994                 *setup_frm++ = hash_table[i];
 995         }
 996         setup_frm = &tp->setup_frame[13*6];
 997
 998         /* Fill the final entry with our physical address. */
 999         eaddrs = (u16 *)dev->dev_addr;
1000         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
1001         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
1002         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
1003 }
1004
1005 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
1006 {
1007         struct tulip_private *tp = netdev_priv(dev);
1008         struct dev_mc_list *mclist;
1009         int i;
1010         u16 *eaddrs;
1011
1012         /* We have <= 14 addresses so we can use the wonderful
1013            16 address perfect filtering of the Tulip. */
1014         for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
1015              i++, mclist = mclist->next) {
1016                 eaddrs = (u16 *)mclist->dmi_addr;
1017                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
1018                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
1019                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
1020         }
1021         /* Fill the unused entries with the broadcast address. */
1022         memset(setup_frm, 0xff, (15-i)*12);
1023         setup_frm = &tp->setup_frame[15*6];
1024
1025         /* Fill the final entry with our physical address. */
1026         eaddrs = (u16 *)dev->dev_addr;
1027         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
1028         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
1029         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
1030 }
1031
1032
1033 static void set_rx_mode(struct net_device *dev)
1034 {
1035         struct tulip_private *tp = netdev_priv(dev);
1036         void __iomem *ioaddr = tp->base_addr;
1037         int csr6;
1038
1039         csr6 = ioread32(ioaddr + CSR6) & ~0x00D5;
1040
1041         tp->csr6 &= ~0x00D5;
1042         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1043                 tp->csr6 |= AcceptAllMulticast | AcceptAllPhys;
1044                 csr6 |= AcceptAllMulticast | AcceptAllPhys;
1045         } else if ((dev->mc_count > 1000)  ||  (dev->flags & IFF_ALLMULTI)) {
1046                 /* Too many to filter well -- accept all multicasts. */
1047                 tp->csr6 |= AcceptAllMulticast;
1048                 csr6 |= AcceptAllMulticast;
1049         } else  if (tp->flags & MC_HASH_ONLY) {
1050                 /* Some work-alikes have only a 64-entry hash filter table. */
1051                 /* Should verify correctness on big-endian/__powerpc__ */
1052                 struct dev_mc_list *mclist;
1053                 int i;
1054                 if (dev->mc_count > 64) {               /* Arbitrary non-effective limit. */
1055                         tp->csr6 |= AcceptAllMulticast;
1056                         csr6 |= AcceptAllMulticast;
1057                 } else {
1058                         u32 mc_filter[2] = {0, 0};               /* Multicast hash filter */
1059                         int filterbit;
1060                         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1061                                  i++, mclist = mclist->next) {
1062                                 if (tp->flags & COMET_MAC_ADDR)
1063                                         filterbit = ether_crc_le(ETH_ALEN, mclist->dmi_addr);
1064                                 else
1065                                         filterbit = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1066                                 filterbit &= 0x3f;
1067                                 mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
1068                                 if (tulip_debug > 2)
1069                                         printk(KERN_INFO "%s: Added filter for %pM"
1070                                                "  %8.8x bit %d.\n",
1071                                                dev->name, mclist->dmi_addr,
1072                                                ether_crc(ETH_ALEN, mclist->dmi_addr), filterbit);
1073                         }
1074                         if (mc_filter[0] == tp->mc_filter[0]  &&
1075                                 mc_filter[1] == tp->mc_filter[1])
1076                                 ;                               /* No change. */
1077                         else if (tp->flags & IS_ASIX) {
1078                                 iowrite32(2, ioaddr + CSR13);
1079                                 iowrite32(mc_filter[0], ioaddr + CSR14);
1080                                 iowrite32(3, ioaddr + CSR13);
1081                                 iowrite32(mc_filter[1], ioaddr + CSR14);
1082                         } else if (tp->flags & COMET_MAC_ADDR) {
1083                                 iowrite32(mc_filter[0], ioaddr + 0xAC);
1084                                 iowrite32(mc_filter[1], ioaddr + 0xB0);
1085                         }
1086                         tp->mc_filter[0] = mc_filter[0];
1087                         tp->mc_filter[1] = mc_filter[1];
1088                 }
1089         } else {
1090                 unsigned long flags;
1091                 u32 tx_flags = 0x08000000 | 192;
1092
1093                 /* Note that only the low-address shortword of setup_frame is valid!
1094                    The values are doubled for big-endian architectures. */
1095                 if (dev->mc_count > 14) { /* Must use a multicast hash table. */
1096                         build_setup_frame_hash(tp->setup_frame, dev);
1097                         tx_flags = 0x08400000 | 192;
1098                 } else {
1099                         build_setup_frame_perfect(tp->setup_frame, dev);
1100                 }
1101
1102                 spin_lock_irqsave(&tp->lock, flags);
1103
1104                 if (tp->cur_tx - tp->dirty_tx > TX_RING_SIZE - 2) {
1105                         /* Same setup recently queued, we need not add it. */
1106                 } else {
1107                         unsigned int entry;
1108                         int dummy = -1;
1109
1110                         /* Now add this frame to the Tx list. */
1111
1112                         entry = tp->cur_tx++ % TX_RING_SIZE;
1113
1114                         if (entry != 0) {
1115                                 /* Avoid a chip errata by prefixing a dummy entry. */
1116                                 tp->tx_buffers[entry].skb = NULL;
1117                                 tp->tx_buffers[entry].mapping = 0;
1118                                 tp->tx_ring[entry].length =
1119                                         (entry == TX_RING_SIZE-1) ? cpu_to_le32(DESC_RING_WRAP) : 0;
1120                                 tp->tx_ring[entry].buffer1 = 0;
1121                                 /* Must set DescOwned later to avoid race with chip */
1122                                 dummy = entry;
1123                                 entry = tp->cur_tx++ % TX_RING_SIZE;
1124
1125                         }
1126
1127                         tp->tx_buffers[entry].skb = NULL;
1128                         tp->tx_buffers[entry].mapping =
1129                                 pci_map_single(tp->pdev, tp->setup_frame,
1130                                                sizeof(tp->setup_frame),
1131                                                PCI_DMA_TODEVICE);
1132                         /* Put the setup frame on the Tx list. */
1133                         if (entry == TX_RING_SIZE-1)
1134                                 tx_flags |= DESC_RING_WRAP;             /* Wrap ring. */
1135                         tp->tx_ring[entry].length = cpu_to_le32(tx_flags);
1136                         tp->tx_ring[entry].buffer1 =
1137                                 cpu_to_le32(tp->tx_buffers[entry].mapping);
1138                         tp->tx_ring[entry].status = cpu_to_le32(DescOwned);
1139                         if (dummy >= 0)
1140                                 tp->tx_ring[dummy].status = cpu_to_le32(DescOwned);
1141                         if (tp->cur_tx - tp->dirty_tx >= TX_RING_SIZE - 2)
1142                                 netif_stop_queue(dev);
1143
1144                         /* Trigger an immediate transmit demand. */
1145                         iowrite32(0, ioaddr + CSR1);
1146                 }
1147
1148                 spin_unlock_irqrestore(&tp->lock, flags);
1149         }
1150
1151         iowrite32(csr6, ioaddr + CSR6);
1152 }
1153
1154 #ifdef CONFIG_TULIP_MWI
1155 static void __devinit tulip_mwi_config (struct pci_dev *pdev,
1156                                         struct net_device *dev)
1157 {
1158         struct tulip_private *tp = netdev_priv(dev);
1159         u8 cache;
1160         u16 pci_command;
1161         u32 csr0;
1162
1163         if (tulip_debug > 3)
1164                 printk(KERN_DEBUG "%s: tulip_mwi_config()\n", pci_name(pdev));
1165
1166         tp->csr0 = csr0 = 0;
1167
1168         /* if we have any cache line size at all, we can do MRM and MWI */
1169         csr0 |= MRM | MWI;
1170
1171         /* Enable MWI in the standard PCI command bit.
1172          * Check for the case where MWI is desired but not available
1173          */
1174         pci_try_set_mwi(pdev);
1175
1176         /* read result from hardware (in case bit refused to enable) */
1177         pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
1178         if ((csr0 & MWI) && (!(pci_command & PCI_COMMAND_INVALIDATE)))
1179                 csr0 &= ~MWI;
1180
1181         /* if cache line size hardwired to zero, no MWI */
1182         pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache);
1183         if ((csr0 & MWI) && (cache == 0)) {
1184                 csr0 &= ~MWI;
1185                 pci_clear_mwi(pdev);
1186         }
1187
1188         /* assign per-cacheline-size cache alignment and
1189          * burst length values
1190          */
1191         switch (cache) {
1192         case 8:
1193                 csr0 |= MRL | (1 << CALShift) | (16 << BurstLenShift);
1194                 break;
1195         case 16:
1196                 csr0 |= MRL | (2 << CALShift) | (16 << BurstLenShift);
1197                 break;
1198         case 32:
1199                 csr0 |= MRL | (3 << CALShift) | (32 << BurstLenShift);
1200                 break;
1201         default:
1202                 cache = 0;
1203                 break;
1204         }
1205
1206         /* if we have a good cache line size, we by now have a good
1207          * csr0, so save it and exit
1208          */
1209         if (cache)
1210                 goto out;
1211
1212         /* we don't have a good csr0 or cache line size, disable MWI */
1213         if (csr0 & MWI) {
1214                 pci_clear_mwi(pdev);
1215                 csr0 &= ~MWI;
1216         }
1217
1218         /* sane defaults for burst length and cache alignment
1219          * originally from de4x5 driver
1220          */
1221         csr0 |= (8 << BurstLenShift) | (1 << CALShift);
1222
1223 out:
1224         tp->csr0 = csr0;
1225         if (tulip_debug > 2)
1226                 printk(KERN_DEBUG "%s: MWI config cacheline=%d, csr0=%08x\n",
1227                        pci_name(pdev), cache, csr0);
1228 }
1229 #endif
1230
1231 /*
1232  *      Chips that have the MRM/reserved bit quirk and the burst quirk. That
1233  *      is the DM910X and the on chip ULi devices
1234  */
1235
1236 static int tulip_uli_dm_quirk(struct pci_dev *pdev)
1237 {
1238         if (pdev->vendor == 0x1282 && pdev->device == 0x9102)
1239                 return 1;
1240         return 0;
1241 }
1242
1243 static const struct net_device_ops tulip_netdev_ops = {
1244         .ndo_open               = tulip_open,
1245         .ndo_start_xmit         = tulip_start_xmit,
1246         .ndo_tx_timeout         = tulip_tx_timeout,
1247         .ndo_stop               = tulip_close,
1248         .ndo_get_stats          = tulip_get_stats,
1249         .ndo_do_ioctl           = private_ioctl,
1250         .ndo_set_multicast_list = set_rx_mode,
1251         .ndo_change_mtu         = eth_change_mtu,
1252         .ndo_set_mac_address    = eth_mac_addr,
1253         .ndo_validate_addr      = eth_validate_addr,
1254 #ifdef CONFIG_NET_POLL_CONTROLLER
1255         .ndo_poll_controller     = poll_tulip,
1256 #endif
1257 };
1258
1259 static int __devinit tulip_init_one (struct pci_dev *pdev,
1260                                      const struct pci_device_id *ent)
1261 {
1262         struct tulip_private *tp;
1263         /* See note below on the multiport cards. */
1264         static unsigned char last_phys_addr[6] = {0x00, 'L', 'i', 'n', 'u', 'x'};
1265         static struct pci_device_id early_486_chipsets[] = {
1266                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82424) },
1267                 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_496) },
1268                 { },
1269         };
1270         static int last_irq;
1271         static int multiport_cnt;       /* For four-port boards w/one EEPROM */
1272         int i, irq;
1273         unsigned short sum;
1274         unsigned char *ee_data;
1275         struct net_device *dev;
1276         void __iomem *ioaddr;
1277         static int board_idx = -1;
1278         int chip_idx = ent->driver_data;
1279         const char *chip_name = tulip_tbl[chip_idx].chip_name;
1280         unsigned int eeprom_missing = 0;
1281         unsigned int force_csr0 = 0;
1282
1283 #ifndef MODULE
1284         static int did_version;         /* Already printed version info. */
1285         if (tulip_debug > 0  &&  did_version++ == 0)
1286                 printk (KERN_INFO "%s", version);
1287 #endif
1288
1289         board_idx++;
1290
1291         /*
1292          *      Lan media wire a tulip chip to a wan interface. Needs a very
1293          *      different driver (lmc driver)
1294          */
1295
1296         if (pdev->subsystem_vendor == PCI_VENDOR_ID_LMC) {
1297                 printk (KERN_ERR PFX "skipping LMC card.\n");
1298                 return -ENODEV;
1299         }
1300
1301         /*
1302          *      Early DM9100's need software CRC and the DMFE driver
1303          */
1304
1305         if (pdev->vendor == 0x1282 && pdev->device == 0x9100)
1306         {
1307                 /* Read Chip revision */
1308                 if (pdev->revision < 0x30)
1309                 {
1310                         printk(KERN_ERR PFX "skipping early DM9100 with Crc bug (use dmfe)\n");
1311                         return -ENODEV;
1312                 }
1313         }
1314
1315         /*
1316          *      Looks for early PCI chipsets where people report hangs
1317          *      without the workarounds being on.
1318          */
1319
1320         /* 1. Intel Saturn. Switch to 8 long words burst, 8 long word cache
1321               aligned.  Aries might need this too. The Saturn errata are not
1322               pretty reading but thankfully it's an old 486 chipset.
1323
1324            2. The dreaded SiS496 486 chipset. Same workaround as Intel
1325               Saturn.
1326         */
1327
1328         if (pci_dev_present(early_486_chipsets)) {
1329                 csr0 = MRL | MRM | (8 << BurstLenShift) | (1 << CALShift);
1330                 force_csr0 = 1;
1331         }
1332
1333         /* bugfix: the ASIX must have a burst limit or horrible things happen. */
1334         if (chip_idx == AX88140) {
1335                 if ((csr0 & 0x3f00) == 0)
1336                         csr0 |= 0x2000;
1337         }
1338
1339         /* PNIC doesn't have MWI/MRL/MRM... */
1340         if (chip_idx == LC82C168)
1341                 csr0 &= ~0xfff10000; /* zero reserved bits 31:20, 16 */
1342
1343         /* DM9102A has troubles with MRM & clear reserved bits 24:22, 20, 16, 7:1 */
1344         if (tulip_uli_dm_quirk(pdev)) {
1345                 csr0 &= ~0x01f100ff;
1346 #if defined(CONFIG_SPARC)
1347                 csr0 = (csr0 & ~0xff00) | 0xe000;
1348 #endif
1349         }
1350         /*
1351          *      And back to business
1352          */
1353
1354         i = pci_enable_device(pdev);
1355         if (i) {
1356                 printk (KERN_ERR PFX
1357                         "Cannot enable tulip board #%d, aborting\n",
1358                         board_idx);
1359                 return i;
1360         }
1361
1362         irq = pdev->irq;
1363
1364         /* alloc_etherdev ensures aligned and zeroed private structures */
1365         dev = alloc_etherdev (sizeof (*tp));
1366         if (!dev) {
1367                 printk (KERN_ERR PFX "ether device alloc failed, aborting\n");
1368                 return -ENOMEM;
1369         }
1370
1371         SET_NETDEV_DEV(dev, &pdev->dev);
1372         if (pci_resource_len (pdev, 0) < tulip_tbl[chip_idx].io_size) {
1373                 printk (KERN_ERR PFX "%s: I/O region (0x%llx@0x%llx) too small, "
1374                         "aborting\n", pci_name(pdev),
1375                         (unsigned long long)pci_resource_len (pdev, 0),
1376                         (unsigned long long)pci_resource_start (pdev, 0));
1377                 goto err_out_free_netdev;
1378         }
1379
1380         /* grab all resources from both PIO and MMIO regions, as we
1381          * don't want anyone else messing around with our hardware */
1382         if (pci_request_regions (pdev, "tulip"))
1383                 goto err_out_free_netdev;
1384
1385         ioaddr =  pci_iomap(pdev, TULIP_BAR, tulip_tbl[chip_idx].io_size);
1386
1387         if (!ioaddr)
1388                 goto err_out_free_res;
1389
1390         /*
1391          * initialize private data structure 'tp'
1392          * it is zeroed and aligned in alloc_etherdev
1393          */
1394         tp = netdev_priv(dev);
1395         tp->dev = dev;
1396
1397         tp->rx_ring = pci_alloc_consistent(pdev,
1398                                            sizeof(struct tulip_rx_desc) * RX_RING_SIZE +
1399                                            sizeof(struct tulip_tx_desc) * TX_RING_SIZE,
1400                                            &tp->rx_ring_dma);
1401         if (!tp->rx_ring)
1402                 goto err_out_mtable;
1403         tp->tx_ring = (struct tulip_tx_desc *)(tp->rx_ring + RX_RING_SIZE);
1404         tp->tx_ring_dma = tp->rx_ring_dma + sizeof(struct tulip_rx_desc) * RX_RING_SIZE;
1405
1406         tp->chip_id = chip_idx;
1407         tp->flags = tulip_tbl[chip_idx].flags;
1408         tp->pdev = pdev;
1409         tp->base_addr = ioaddr;
1410         tp->revision = pdev->revision;
1411         tp->csr0 = csr0;
1412         spin_lock_init(&tp->lock);
1413         spin_lock_init(&tp->mii_lock);
1414         init_timer(&tp->timer);
1415         tp->timer.data = (unsigned long)dev;
1416         tp->timer.function = tulip_tbl[tp->chip_id].media_timer;
1417
1418         INIT_WORK(&tp->media_work, tulip_tbl[tp->chip_id].media_task);
1419
1420         dev->base_addr = (unsigned long)ioaddr;
1421
1422 #ifdef CONFIG_TULIP_MWI
1423         if (!force_csr0 && (tp->flags & HAS_PCI_MWI))
1424                 tulip_mwi_config (pdev, dev);
1425 #endif
1426
1427         /* Stop the chip's Tx and Rx processes. */
1428         tulip_stop_rxtx(tp);
1429
1430         pci_set_master(pdev);
1431
1432 #ifdef CONFIG_GSC
1433         if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP) {
1434                 switch (pdev->subsystem_device) {
1435                 default:
1436                         break;
1437                 case 0x1061:
1438                 case 0x1062:
1439                 case 0x1063:
1440                 case 0x1098:
1441                 case 0x1099:
1442                 case 0x10EE:
1443                         tp->flags |= HAS_SWAPPED_SEEPROM | NEEDS_FAKE_MEDIA_TABLE;
1444                         chip_name = "GSC DS21140 Tulip";
1445                 }
1446         }
1447 #endif
1448
1449         /* Clear the missed-packet counter. */
1450         ioread32(ioaddr + CSR8);
1451
1452         /* The station address ROM is read byte serially.  The register must
1453            be polled, waiting for the value to be read bit serially from the
1454            EEPROM.
1455            */
1456         ee_data = tp->eeprom;
1457         memset(ee_data, 0, sizeof(tp->eeprom));
1458         sum = 0;
1459         if (chip_idx == LC82C168) {
1460                 for (i = 0; i < 3; i++) {
1461                         int value, boguscnt = 100000;
1462                         iowrite32(0x600 | i, ioaddr + 0x98);
1463                         do {
1464                                 value = ioread32(ioaddr + CSR9);
1465                         } while (value < 0  && --boguscnt > 0);
1466                         put_unaligned_le16(value, ((__le16 *)dev->dev_addr) + i);
1467                         sum += value & 0xffff;
1468                 }
1469         } else if (chip_idx == COMET) {
1470                 /* No need to read the EEPROM. */
1471                 put_unaligned_le32(ioread32(ioaddr + 0xA4), dev->dev_addr);
1472                 put_unaligned_le16(ioread32(ioaddr + 0xA8), dev->dev_addr + 4);
1473                 for (i = 0; i < 6; i ++)
1474                         sum += dev->dev_addr[i];
1475         } else {
1476                 /* A serial EEPROM interface, we read now and sort it out later. */
1477                 int sa_offset = 0;
1478                 int ee_addr_size = tulip_read_eeprom(dev, 0xff, 8) & 0x40000 ? 8 : 6;
1479                 int ee_max_addr = ((1 << ee_addr_size) - 1) * sizeof(u16);
1480
1481                 if (ee_max_addr > sizeof(tp->eeprom))
1482                         ee_max_addr = sizeof(tp->eeprom);
1483
1484                 for (i = 0; i < ee_max_addr ; i += sizeof(u16)) {
1485                         u16 data = tulip_read_eeprom(dev, i/2, ee_addr_size);
1486                         ee_data[i] = data & 0xff;
1487                         ee_data[i + 1] = data >> 8;
1488                 }
1489
1490                 /* DEC now has a specification (see Notes) but early board makers
1491                    just put the address in the first EEPROM locations. */
1492                 /* This does  memcmp(ee_data, ee_data+16, 8) */
1493                 for (i = 0; i < 8; i ++)
1494                         if (ee_data[i] != ee_data[16+i])
1495                                 sa_offset = 20;
1496                 if (chip_idx == CONEXANT) {
1497                         /* Check that the tuple type and length is correct. */
1498                         if (ee_data[0x198] == 0x04  &&  ee_data[0x199] == 6)
1499                                 sa_offset = 0x19A;
1500                 } else if (ee_data[0] == 0xff  &&  ee_data[1] == 0xff &&
1501                                    ee_data[2] == 0) {
1502                         sa_offset = 2;          /* Grrr, damn Matrox boards. */
1503                         multiport_cnt = 4;
1504                 }
1505 #ifdef CONFIG_MIPS_COBALT
1506                if ((pdev->bus->number == 0) &&
1507                    ((PCI_SLOT(pdev->devfn) == 7) ||
1508                     (PCI_SLOT(pdev->devfn) == 12))) {
1509                        /* Cobalt MAC address in first EEPROM locations. */
1510                        sa_offset = 0;
1511                        /* Ensure our media table fixup get's applied */
1512                        memcpy(ee_data + 16, ee_data, 8);
1513                }
1514 #endif
1515 #ifdef CONFIG_GSC
1516                 /* Check to see if we have a broken srom */
1517                 if (ee_data[0] == 0x61 && ee_data[1] == 0x10) {
1518                         /* pci_vendor_id and subsystem_id are swapped */
1519                         ee_data[0] = ee_data[2];
1520                         ee_data[1] = ee_data[3];
1521                         ee_data[2] = 0x61;
1522                         ee_data[3] = 0x10;
1523
1524                         /* HSC-PCI boards need to be byte-swaped and shifted
1525                          * up 1 word.  This shift needs to happen at the end
1526                          * of the MAC first because of the 2 byte overlap.
1527                          */
1528                         for (i = 4; i >= 0; i -= 2) {
1529                                 ee_data[17 + i + 3] = ee_data[17 + i];
1530                                 ee_data[16 + i + 5] = ee_data[16 + i];
1531                         }
1532                 }
1533 #endif
1534
1535                 for (i = 0; i < 6; i ++) {
1536                         dev->dev_addr[i] = ee_data[i + sa_offset];
1537                         sum += ee_data[i + sa_offset];
1538                 }
1539         }
1540         /* Lite-On boards have the address byte-swapped. */
1541         if ((dev->dev_addr[0] == 0xA0  ||  dev->dev_addr[0] == 0xC0 || dev->dev_addr[0] == 0x02)
1542                 &&  dev->dev_addr[1] == 0x00)
1543                 for (i = 0; i < 6; i+=2) {
1544                         char tmp = dev->dev_addr[i];
1545                         dev->dev_addr[i] = dev->dev_addr[i+1];
1546                         dev->dev_addr[i+1] = tmp;
1547                 }
1548         /* On the Zynx 315 Etherarray and other multiport boards only the
1549            first Tulip has an EEPROM.
1550            On Sparc systems the mac address is held in the OBP property
1551            "local-mac-address".
1552            The addresses of the subsequent ports are derived from the first.
1553            Many PCI BIOSes also incorrectly report the IRQ line, so we correct
1554            that here as well. */
1555         if (sum == 0  || sum == 6*0xff) {
1556 #if defined(CONFIG_SPARC)
1557                 struct device_node *dp = pci_device_to_OF_node(pdev);
1558                 const unsigned char *addr;
1559                 int len;
1560 #endif
1561                 eeprom_missing = 1;
1562                 for (i = 0; i < 5; i++)
1563                         dev->dev_addr[i] = last_phys_addr[i];
1564                 dev->dev_addr[i] = last_phys_addr[i] + 1;
1565 #if defined(CONFIG_SPARC)
1566                 addr = of_get_property(dp, "local-mac-address", &len);
1567                 if (addr && len == 6)
1568                         memcpy(dev->dev_addr, addr, 6);
1569 #endif
1570 #if defined(__i386__) || defined(__x86_64__)    /* Patch up x86 BIOS bug. */
1571                 if (last_irq)
1572                         irq = last_irq;
1573 #endif
1574         }
1575
1576         for (i = 0; i < 6; i++)
1577                 last_phys_addr[i] = dev->dev_addr[i];
1578         last_irq = irq;
1579         dev->irq = irq;
1580
1581         /* The lower four bits are the media type. */
1582         if (board_idx >= 0  &&  board_idx < MAX_UNITS) {
1583                 if (options[board_idx] & MEDIA_MASK)
1584                         tp->default_port = options[board_idx] & MEDIA_MASK;
1585                 if ((options[board_idx] & FullDuplex) || full_duplex[board_idx] > 0)
1586                         tp->full_duplex = 1;
1587                 if (mtu[board_idx] > 0)
1588                         dev->mtu = mtu[board_idx];
1589         }
1590         if (dev->mem_start & MEDIA_MASK)
1591                 tp->default_port = dev->mem_start & MEDIA_MASK;
1592         if (tp->default_port) {
1593                 printk(KERN_INFO "tulip%d: Transceiver selection forced to %s.\n",
1594                        board_idx, medianame[tp->default_port & MEDIA_MASK]);
1595                 tp->medialock = 1;
1596                 if (tulip_media_cap[tp->default_port] & MediaAlwaysFD)
1597                         tp->full_duplex = 1;
1598         }
1599         if (tp->full_duplex)
1600                 tp->full_duplex_lock = 1;
1601
1602         if (tulip_media_cap[tp->default_port] & MediaIsMII) {
1603                 u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60, 0x80, 0x100, 0x200 };
1604                 tp->mii_advertise = media2advert[tp->default_port - 9];
1605                 tp->mii_advertise |= (tp->flags & HAS_8023X); /* Matching bits! */
1606         }
1607
1608         if (tp->flags & HAS_MEDIA_TABLE) {
1609                 sprintf(dev->name, "tulip%d", board_idx);       /* hack */
1610                 tulip_parse_eeprom(dev);
1611                 strcpy(dev->name, "eth%d");                     /* un-hack */
1612         }
1613
1614         if ((tp->flags & ALWAYS_CHECK_MII) ||
1615                 (tp->mtable  &&  tp->mtable->has_mii) ||
1616                 ( ! tp->mtable  &&  (tp->flags & HAS_MII))) {
1617                 if (tp->mtable  &&  tp->mtable->has_mii) {
1618                         for (i = 0; i < tp->mtable->leafcount; i++)
1619                                 if (tp->mtable->mleaf[i].media == 11) {
1620                                         tp->cur_index = i;
1621                                         tp->saved_if_port = dev->if_port;
1622                                         tulip_select_media(dev, 2);
1623                                         dev->if_port = tp->saved_if_port;
1624                                         break;
1625                                 }
1626                 }
1627
1628                 /* Find the connected MII xcvrs.
1629                    Doing this in open() would allow detecting external xcvrs
1630                    later, but takes much time. */
1631                 tulip_find_mii (dev, board_idx);
1632         }
1633
1634         /* The Tulip-specific entries in the device structure. */
1635         dev->netdev_ops = &tulip_netdev_ops;
1636         dev->watchdog_timeo = TX_TIMEOUT;
1637 #ifdef CONFIG_TULIP_NAPI
1638         netif_napi_add(dev, &tp->napi, tulip_poll, 16);
1639 #endif
1640         SET_ETHTOOL_OPS(dev, &ops);
1641
1642         if (register_netdev(dev))
1643                 goto err_out_free_ring;
1644
1645         printk(KERN_INFO "%s: %s rev %d at "
1646 #ifdef CONFIG_TULIP_MMIO
1647                 "MMIO"
1648 #else
1649                 "Port"
1650 #endif
1651                 " %#llx,", dev->name, chip_name, pdev->revision,
1652                 (unsigned long long) pci_resource_start(pdev, TULIP_BAR));
1653         pci_set_drvdata(pdev, dev);
1654
1655         if (eeprom_missing)
1656                 printk(" EEPROM not present,");
1657         printk(" %pM", dev->dev_addr);
1658         printk(", IRQ %d.\n", irq);
1659
1660         if (tp->chip_id == PNIC2)
1661                 tp->link_change = pnic2_lnk_change;
1662         else if (tp->flags & HAS_NWAY)
1663                 tp->link_change = t21142_lnk_change;
1664         else if (tp->flags & HAS_PNICNWAY)
1665                 tp->link_change = pnic_lnk_change;
1666
1667         /* Reset the xcvr interface and turn on heartbeat. */
1668         switch (chip_idx) {
1669         case DC21140:
1670         case DM910X:
1671         default:
1672                 if (tp->mtable)
1673                         iowrite32(tp->mtable->csr12dir | 0x100, ioaddr + CSR12);
1674                 break;
1675         case DC21142:
1676                 if (tp->mii_cnt  ||  tulip_media_cap[dev->if_port] & MediaIsMII) {
1677                         iowrite32(csr6_mask_defstate, ioaddr + CSR6);
1678                         iowrite32(0x0000, ioaddr + CSR13);
1679                         iowrite32(0x0000, ioaddr + CSR14);
1680                         iowrite32(csr6_mask_hdcap, ioaddr + CSR6);
1681                 } else
1682                         t21142_start_nway(dev);
1683                 break;
1684         case PNIC2:
1685                 /* just do a reset for sanity sake */
1686                 iowrite32(0x0000, ioaddr + CSR13);
1687                 iowrite32(0x0000, ioaddr + CSR14);
1688                 break;
1689         case LC82C168:
1690                 if ( ! tp->mii_cnt) {
1691                         tp->nway = 1;
1692                         tp->nwayset = 0;
1693                         iowrite32(csr6_ttm | csr6_ca, ioaddr + CSR6);
1694                         iowrite32(0x30, ioaddr + CSR12);
1695                         iowrite32(0x0001F078, ioaddr + CSR6);
1696                         iowrite32(0x0201F078, ioaddr + CSR6); /* Turn on autonegotiation. */
1697                 }
1698                 break;
1699         case MX98713:
1700         case COMPEX9881:
1701                 iowrite32(0x00000000, ioaddr + CSR6);
1702                 iowrite32(0x000711C0, ioaddr + CSR14); /* Turn on NWay. */
1703                 iowrite32(0x00000001, ioaddr + CSR13);
1704                 break;
1705         case MX98715:
1706         case MX98725:
1707                 iowrite32(0x01a80000, ioaddr + CSR6);
1708                 iowrite32(0xFFFFFFFF, ioaddr + CSR14);
1709                 iowrite32(0x00001000, ioaddr + CSR12);
1710                 break;
1711         case COMET:
1712                 /* No initialization necessary. */
1713                 break;
1714         }
1715
1716         /* put the chip in snooze mode until opened */
1717         tulip_set_power_state (tp, 0, 1);
1718
1719         return 0;
1720
1721 err_out_free_ring:
1722         pci_free_consistent (pdev,
1723                              sizeof (struct tulip_rx_desc) * RX_RING_SIZE +
1724                              sizeof (struct tulip_tx_desc) * TX_RING_SIZE,
1725                              tp->rx_ring, tp->rx_ring_dma);
1726
1727 err_out_mtable:
1728         kfree (tp->mtable);
1729         pci_iounmap(pdev, ioaddr);
1730
1731 err_out_free_res:
1732         pci_release_regions (pdev);
1733
1734 err_out_free_netdev:
1735         free_netdev (dev);
1736         return -ENODEV;
1737 }
1738
1739
1740 #ifdef CONFIG_PM
1741
1742 static int tulip_suspend (struct pci_dev *pdev, pm_message_t state)
1743 {
1744         struct net_device *dev = pci_get_drvdata(pdev);
1745
1746         if (!dev)
1747                 return -EINVAL;
1748
1749         if (!netif_running(dev))
1750                 goto save_state;
1751
1752         tulip_down(dev);
1753
1754         netif_device_detach(dev);
1755         free_irq(dev->irq, dev);
1756
1757 save_state:
1758         pci_save_state(pdev);
1759         pci_disable_device(pdev);
1760         pci_set_power_state(pdev, pci_choose_state(pdev, state));
1761
1762         return 0;
1763 }
1764
1765
1766 static int tulip_resume(struct pci_dev *pdev)
1767 {
1768         struct net_device *dev = pci_get_drvdata(pdev);
1769         int retval;
1770
1771         if (!dev)
1772                 return -EINVAL;
1773
1774         pci_set_power_state(pdev, PCI_D0);
1775         pci_restore_state(pdev);
1776
1777         if (!netif_running(dev))
1778                 return 0;
1779
1780         if ((retval = pci_enable_device(pdev))) {
1781                 printk (KERN_ERR "tulip: pci_enable_device failed in resume\n");
1782                 return retval;
1783         }
1784
1785         if ((retval = request_irq(dev->irq, &tulip_interrupt, IRQF_SHARED, dev->name, dev))) {
1786                 printk (KERN_ERR "tulip: request_irq failed in resume\n");
1787                 return retval;
1788         }
1789
1790         netif_device_attach(dev);
1791
1792         if (netif_running(dev))
1793                 tulip_up(dev);
1794
1795         return 0;
1796 }
1797
1798 #endif /* CONFIG_PM */
1799
1800
1801 static void __devexit tulip_remove_one (struct pci_dev *pdev)
1802 {
1803         struct net_device *dev = pci_get_drvdata (pdev);
1804         struct tulip_private *tp;
1805
1806         if (!dev)
1807                 return;
1808
1809         tp = netdev_priv(dev);
1810         unregister_netdev(dev);
1811         pci_free_consistent (pdev,
1812                              sizeof (struct tulip_rx_desc) * RX_RING_SIZE +
1813                              sizeof (struct tulip_tx_desc) * TX_RING_SIZE,
1814                              tp->rx_ring, tp->rx_ring_dma);
1815         kfree (tp->mtable);
1816         pci_iounmap(pdev, tp->base_addr);
1817         free_netdev (dev);
1818         pci_release_regions (pdev);
1819         pci_set_drvdata (pdev, NULL);
1820
1821         /* pci_power_off (pdev, -1); */
1822 }
1823
1824 #ifdef CONFIG_NET_POLL_CONTROLLER
1825 /*
1826  * Polling 'interrupt' - used by things like netconsole to send skbs
1827  * without having to re-enable interrupts. It's not called while
1828  * the interrupt routine is executing.
1829  */
1830
1831 static void poll_tulip (struct net_device *dev)
1832 {
1833         /* disable_irq here is not very nice, but with the lockless
1834            interrupt handler we have no other choice. */
1835         disable_irq(dev->irq);
1836         tulip_interrupt (dev->irq, dev);
1837         enable_irq(dev->irq);
1838 }
1839 #endif
1840
1841 static struct pci_driver tulip_driver = {
1842         .name           = DRV_NAME,
1843         .id_table       = tulip_pci_tbl,
1844         .probe          = tulip_init_one,
1845         .remove         = __devexit_p(tulip_remove_one),
1846 #ifdef CONFIG_PM
1847         .suspend        = tulip_suspend,
1848         .resume         = tulip_resume,
1849 #endif /* CONFIG_PM */
1850 };
1851
1852
1853 static int __init tulip_init (void)
1854 {
1855 #ifdef MODULE
1856         printk (KERN_INFO "%s", version);
1857 #endif
1858
1859         /* copy module parms into globals */
1860         tulip_rx_copybreak = rx_copybreak;
1861         tulip_max_interrupt_work = max_interrupt_work;
1862
1863         /* probe for and init boards */
1864         return pci_register_driver(&tulip_driver);
1865 }
1866
1867
1868 static void __exit tulip_cleanup (void)
1869 {
1870         pci_unregister_driver (&tulip_driver);
1871 }
1872
1873
1874 module_init(tulip_init);
1875 module_exit(tulip_cleanup);