drivers/net/tulip/tulip_core.c

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