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