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