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