]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - drivers/net/tulip/de2104x.c
projects / mirror_ubuntu-kernels.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'nfs-server-stable' of git://linux-nfs.org/~bfields/linux
[mirror_ubuntu-kernels.git] / drivers / net / tulip / de2104x.c
1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
2 /*
3 Copyright 2001,2003 Jeff Garzik <jgarzik@pobox.com>
4
5 Copyright 1994, 1995 Digital Equipment Corporation. [de4x5.c]
6 Written/copyright 1994-2001 by Donald Becker. [tulip.c]
7
8 This software may be used and distributed according to the terms of
9 the GNU General Public License (GPL), incorporated herein by reference.
10 Drivers based on or derived from this code fall under the GPL and must
11 retain the authorship, copyright and license notice. This file is not
12 a complete program and may only be used when the entire operating
13 system is licensed under the GPL.
14
15 See the file COPYING in this distribution for more information.
16
17 TODO, in rough priority order:
18 * Support forcing media type with a module parameter,
19 like dl2k.c/sundance.c
20 * Constants (module parms?) for Rx work limit
21 * Complete reset on PciErr
22 * Jumbo frames / dev->change_mtu
23 * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
24 * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
25 * Implement Tx software interrupt mitigation via
26 Tx descriptor bit
27
28 */
29
30 #define DRV_NAME "de2104x"
31 #define DRV_VERSION "0.7"
32 #define DRV_RELDATE "Mar 17, 2004"
33
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/init.h>
39 #include <linux/pci.h>
40 #include <linux/delay.h>
41 #include <linux/ethtool.h>
42 #include <linux/compiler.h>
43 #include <linux/rtnetlink.h>
44 #include <linux/crc32.h>
45
46 #include <asm/io.h>
47 #include <asm/irq.h>
48 #include <asm/uaccess.h>
49 #include <asm/unaligned.h>
50
51 /* These identify the driver base version and may not be removed. */
52 static char version[] =
53 KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
54
55 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
56 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
57 MODULE_LICENSE("GPL");
58 MODULE_VERSION(DRV_VERSION);
59
60 static int debug = -1;
61 module_param (debug, int, 0);
62 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
63
64 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
65 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
66 || defined(CONFIG_SPARC) || defined(__ia64__) \
67 || defined(__sh__) || defined(__mips__)
68 static int rx_copybreak = 1518;
69 #else
70 static int rx_copybreak = 100;
71 #endif
72 module_param (rx_copybreak, int, 0);
73 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
74
75 #define PFX DRV_NAME ": "
76
77 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
78 NETIF_MSG_PROBE | \
79 NETIF_MSG_LINK | \
80 NETIF_MSG_IFDOWN | \
81 NETIF_MSG_IFUP | \
82 NETIF_MSG_RX_ERR | \
83 NETIF_MSG_TX_ERR)
84
85 #define DE_RX_RING_SIZE 64
86 #define DE_TX_RING_SIZE 64
87 #define DE_RING_BYTES \
88 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
89 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
90 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
91 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
92 #define TX_BUFFS_AVAIL(CP) \
93 (((CP)->tx_tail <= (CP)->tx_head) ? \
94 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
95 (CP)->tx_tail - (CP)->tx_head - 1)
96
97 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
98 #define RX_OFFSET 2
99
100 #define DE_SETUP_SKB ((struct sk_buff *) 1)
101 #define DE_DUMMY_SKB ((struct sk_buff *) 2)
102 #define DE_SETUP_FRAME_WORDS 96
103 #define DE_EEPROM_WORDS 256
104 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
105 #define DE_MAX_MEDIA 5
106
107 #define DE_MEDIA_TP_AUTO 0
108 #define DE_MEDIA_BNC 1
109 #define DE_MEDIA_AUI 2
110 #define DE_MEDIA_TP 3
111 #define DE_MEDIA_TP_FD 4
112 #define DE_MEDIA_INVALID DE_MAX_MEDIA
113 #define DE_MEDIA_FIRST 0
114 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
115 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
116
117 #define DE_TIMER_LINK (60 * HZ)
118 #define DE_TIMER_NO_LINK (5 * HZ)
119
120 #define DE_NUM_REGS 16
121 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
122 #define DE_REGS_VER 1
123
124 /* Time in jiffies before concluding the transmitter is hung. */
125 #define TX_TIMEOUT (6*HZ)
126
127 #define DE_UNALIGNED_16(a) (u16)(get_unaligned((u16 *)(a)))
128
129 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
130 to support a pre-NWay full-duplex signaling mechanism using short frames.
131 No one knows what it should be, but if left at its default value some
132 10base2(!) packets trigger a full-duplex-request interrupt. */
133 #define FULL_DUPLEX_MAGIC 0x6969
134
135 enum {
136 /* NIC registers */
137 BusMode = 0x00,
138 TxPoll = 0x08,
139 RxPoll = 0x10,
140 RxRingAddr = 0x18,
141 TxRingAddr = 0x20,
142 MacStatus = 0x28,
143 MacMode = 0x30,
144 IntrMask = 0x38,
145 RxMissed = 0x40,
146 ROMCmd = 0x48,
147 CSR11 = 0x58,
148 SIAStatus = 0x60,
149 CSR13 = 0x68,
150 CSR14 = 0x70,
151 CSR15 = 0x78,
152 PCIPM = 0x40,
153
154 /* BusMode bits */
155 CmdReset = (1 << 0),
156 CacheAlign16 = 0x00008000,
157 BurstLen4 = 0x00000400,
158
159 /* Rx/TxPoll bits */
160 NormalTxPoll = (1 << 0),
161 NormalRxPoll = (1 << 0),
162
163 /* Tx/Rx descriptor status bits */
164 DescOwn = (1 << 31),
165 RxError = (1 << 15),
166 RxErrLong = (1 << 7),
167 RxErrCRC = (1 << 1),
168 RxErrFIFO = (1 << 0),
169 RxErrRunt = (1 << 11),
170 RxErrFrame = (1 << 14),
171 RingEnd = (1 << 25),
172 FirstFrag = (1 << 29),
173 LastFrag = (1 << 30),
174 TxError = (1 << 15),
175 TxFIFOUnder = (1 << 1),
176 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
177 TxMaxCol = (1 << 8),
178 TxOWC = (1 << 9),
179 TxJabber = (1 << 14),
180 SetupFrame = (1 << 27),
181 TxSwInt = (1 << 31),
182
183 /* MacStatus bits */
184 IntrOK = (1 << 16),
185 IntrErr = (1 << 15),
186 RxIntr = (1 << 6),
187 RxEmpty = (1 << 7),
188 TxIntr = (1 << 0),
189 TxEmpty = (1 << 2),
190 PciErr = (1 << 13),
191 TxState = (1 << 22) | (1 << 21) | (1 << 20),
192 RxState = (1 << 19) | (1 << 18) | (1 << 17),
193 LinkFail = (1 << 12),
194 LinkPass = (1 << 4),
195 RxStopped = (1 << 8),
196 TxStopped = (1 << 1),
197
198 /* MacMode bits */
199 TxEnable = (1 << 13),
200 RxEnable = (1 << 1),
201 RxTx = TxEnable | RxEnable,
202 FullDuplex = (1 << 9),
203 AcceptAllMulticast = (1 << 7),
204 AcceptAllPhys = (1 << 6),
205 BOCnt = (1 << 5),
206 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
207 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
208
209 /* ROMCmd bits */
210 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
211 EE_CS = 0x01, /* EEPROM chip select. */
212 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
213 EE_WRITE_0 = 0x01,
214 EE_WRITE_1 = 0x05,
215 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
216 EE_ENB = (0x4800 | EE_CS),
217
218 /* The EEPROM commands include the alway-set leading bit. */
219 EE_READ_CMD = 6,
220
221 /* RxMissed bits */
222 RxMissedOver = (1 << 16),
223 RxMissedMask = 0xffff,
224
225 /* SROM-related bits */
226 SROMC0InfoLeaf = 27,
227 MediaBlockMask = 0x3f,
228 MediaCustomCSRs = (1 << 6),
229
230 /* PCIPM bits */
231 PM_Sleep = (1 << 31),
232 PM_Snooze = (1 << 30),
233 PM_Mask = PM_Sleep | PM_Snooze,
234
235 /* SIAStatus bits */
236 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
237 NWayRestart = (1 << 12),
238 NonselPortActive = (1 << 9),
239 LinkFailStatus = (1 << 2),
240 NetCxnErr = (1 << 1),
241 };
242
243 static const u32 de_intr_mask =
244 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
245 LinkPass | LinkFail | PciErr;
246
247 /*
248 * Set the programmable burst length to 4 longwords for all:
249 * DMA errors result without these values. Cache align 16 long.
250 */
251 static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
252
253 struct de_srom_media_block {
254 u8 opts;
255 u16 csr13;
256 u16 csr14;
257 u16 csr15;
258 } __attribute__((packed));
259
260 struct de_srom_info_leaf {
261 u16 default_media;
262 u8 n_blocks;
263 u8 unused;
264 } __attribute__((packed));
265
266 struct de_desc {
267 __le32 opts1;
268 __le32 opts2;
269 __le32 addr1;
270 __le32 addr2;
271 };
272
273 struct media_info {
274 u16 type; /* DE_MEDIA_xxx */
275 u16 csr13;
276 u16 csr14;
277 u16 csr15;
278 };
279
280 struct ring_info {
281 struct sk_buff *skb;
282 dma_addr_t mapping;
283 };
284
285 struct de_private {
286 unsigned tx_head;
287 unsigned tx_tail;
288 unsigned rx_tail;
289
290 void __iomem *regs;
291 struct net_device *dev;
292 spinlock_t lock;
293
294 struct de_desc *rx_ring;
295 struct de_desc *tx_ring;
296 struct ring_info tx_skb[DE_TX_RING_SIZE];
297 struct ring_info rx_skb[DE_RX_RING_SIZE];
298 unsigned rx_buf_sz;
299 dma_addr_t ring_dma;
300
301 u32 msg_enable;
302
303 struct net_device_stats net_stats;
304
305 struct pci_dev *pdev;
306
307 u16 setup_frame[DE_SETUP_FRAME_WORDS];
308
309 u32 media_type;
310 u32 media_supported;
311 u32 media_advertise;
312 struct media_info media[DE_MAX_MEDIA];
313 struct timer_list media_timer;
314
315 u8 *ee_data;
316 unsigned board_idx;
317 unsigned de21040 : 1;
318 unsigned media_lock : 1;
319 };
320
321
322 static void de_set_rx_mode (struct net_device *dev);
323 static void de_tx (struct de_private *de);
324 static void de_clean_rings (struct de_private *de);
325 static void de_media_interrupt (struct de_private *de, u32 status);
326 static void de21040_media_timer (unsigned long data);
327 static void de21041_media_timer (unsigned long data);
328 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
329
330
331 static struct pci_device_id de_pci_tbl[] = {
332 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
333 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
334 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
335 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
336 { },
337 };
338 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
339
340 static const char * const media_name[DE_MAX_MEDIA] = {
341 "10baseT auto",
342 "BNC",
343 "AUI",
344 "10baseT-HD",
345 "10baseT-FD"
346 };
347
348 /* 21040 transceiver register settings:
349 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
350 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
351 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
352 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
353
354 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
355 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
356 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
357 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
358
359
360 #define dr32(reg) readl(de->regs + (reg))
361 #define dw32(reg,val) writel((val), de->regs + (reg))
362
363
364 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
365 u32 status, u32 len)
366 {
367 if (netif_msg_rx_err (de))
368 printk (KERN_DEBUG
369 "%s: rx err, slot %d status 0x%x len %d\n",
370 de->dev->name, rx_tail, status, len);
371
372 if ((status & 0x38000300) != 0x0300) {
373 /* Ingore earlier buffers. */
374 if ((status & 0xffff) != 0x7fff) {
375 if (netif_msg_rx_err(de))
376 printk(KERN_WARNING "%s: Oversized Ethernet frame "
377 "spanned multiple buffers, status %8.8x!\n",
378 de->dev->name, status);
379 de->net_stats.rx_length_errors++;
380 }
381 } else if (status & RxError) {
382 /* There was a fatal error. */
383 de->net_stats.rx_errors++; /* end of a packet.*/
384 if (status & 0x0890) de->net_stats.rx_length_errors++;
385 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
386 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
387 }
388 }
389
390 static void de_rx (struct de_private *de)
391 {
392 unsigned rx_tail = de->rx_tail;
393 unsigned rx_work = DE_RX_RING_SIZE;
394 unsigned drop = 0;
395 int rc;
396
397 while (rx_work--) {
398 u32 status, len;
399 dma_addr_t mapping;
400 struct sk_buff *skb, *copy_skb;
401 unsigned copying_skb, buflen;
402
403 skb = de->rx_skb[rx_tail].skb;
404 BUG_ON(!skb);
405 rmb();
406 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
407 if (status & DescOwn)
408 break;
409
410 len = ((status >> 16) & 0x7ff) - 4;
411 mapping = de->rx_skb[rx_tail].mapping;
412
413 if (unlikely(drop)) {
414 de->net_stats.rx_dropped++;
415 goto rx_next;
416 }
417
418 if (unlikely((status & 0x38008300) != 0x0300)) {
419 de_rx_err_acct(de, rx_tail, status, len);
420 goto rx_next;
421 }
422
423 copying_skb = (len <= rx_copybreak);
424
425 if (unlikely(netif_msg_rx_status(de)))
426 printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
427 de->dev->name, rx_tail, status, len,
428 copying_skb);
429
430 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
431 copy_skb = dev_alloc_skb (buflen);
432 if (unlikely(!copy_skb)) {
433 de->net_stats.rx_dropped++;
434 drop = 1;
435 rx_work = 100;
436 goto rx_next;
437 }
438
439 if (!copying_skb) {
440 pci_unmap_single(de->pdev, mapping,
441 buflen, PCI_DMA_FROMDEVICE);
442 skb_put(skb, len);
443
444 mapping =
445 de->rx_skb[rx_tail].mapping =
446 pci_map_single(de->pdev, copy_skb->data,
447 buflen, PCI_DMA_FROMDEVICE);
448 de->rx_skb[rx_tail].skb = copy_skb;
449 } else {
450 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
451 skb_reserve(copy_skb, RX_OFFSET);
452 skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
453 len);
454 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
455
456 /* We'll reuse the original ring buffer. */
457 skb = copy_skb;
458 }
459
460 skb->protocol = eth_type_trans (skb, de->dev);
461
462 de->net_stats.rx_packets++;
463 de->net_stats.rx_bytes += skb->len;
464 de->dev->last_rx = jiffies;
465 rc = netif_rx (skb);
466 if (rc == NET_RX_DROP)
467 drop = 1;
468
469 rx_next:
470 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
471 if (rx_tail == (DE_RX_RING_SIZE - 1))
472 de->rx_ring[rx_tail].opts2 =
473 cpu_to_le32(RingEnd | de->rx_buf_sz);
474 else
475 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
476 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
477 rx_tail = NEXT_RX(rx_tail);
478 }
479
480 if (!rx_work)
481 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
482
483 de->rx_tail = rx_tail;
484 }
485
486 static irqreturn_t de_interrupt (int irq, void *dev_instance)
487 {
488 struct net_device *dev = dev_instance;
489 struct de_private *de = dev->priv;
490 u32 status;
491
492 status = dr32(MacStatus);
493 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
494 return IRQ_NONE;
495
496 if (netif_msg_intr(de))
497 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
498 dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
499
500 dw32(MacStatus, status);
501
502 if (status & (RxIntr | RxEmpty)) {
503 de_rx(de);
504 if (status & RxEmpty)
505 dw32(RxPoll, NormalRxPoll);
506 }
507
508 spin_lock(&de->lock);
509
510 if (status & (TxIntr | TxEmpty))
511 de_tx(de);
512
513 if (status & (LinkPass | LinkFail))
514 de_media_interrupt(de, status);
515
516 spin_unlock(&de->lock);
517
518 if (status & PciErr) {
519 u16 pci_status;
520
521 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
522 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
523 printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
524 dev->name, status, pci_status);
525 }
526
527 return IRQ_HANDLED;
528 }
529
530 static void de_tx (struct de_private *de)
531 {
532 unsigned tx_head = de->tx_head;
533 unsigned tx_tail = de->tx_tail;
534
535 while (tx_tail != tx_head) {
536 struct sk_buff *skb;
537 u32 status;
538
539 rmb();
540 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
541 if (status & DescOwn)
542 break;
543
544 skb = de->tx_skb[tx_tail].skb;
545 BUG_ON(!skb);
546 if (unlikely(skb == DE_DUMMY_SKB))
547 goto next;
548
549 if (unlikely(skb == DE_SETUP_SKB)) {
550 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
551 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
552 goto next;
553 }
554
555 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
556 skb->len, PCI_DMA_TODEVICE);
557
558 if (status & LastFrag) {
559 if (status & TxError) {
560 if (netif_msg_tx_err(de))
561 printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
562 de->dev->name, status);
563 de->net_stats.tx_errors++;
564 if (status & TxOWC)
565 de->net_stats.tx_window_errors++;
566 if (status & TxMaxCol)
567 de->net_stats.tx_aborted_errors++;
568 if (status & TxLinkFail)
569 de->net_stats.tx_carrier_errors++;
570 if (status & TxFIFOUnder)
571 de->net_stats.tx_fifo_errors++;
572 } else {
573 de->net_stats.tx_packets++;
574 de->net_stats.tx_bytes += skb->len;
575 if (netif_msg_tx_done(de))
576 printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
577 }
578 dev_kfree_skb_irq(skb);
579 }
580
581 next:
582 de->tx_skb[tx_tail].skb = NULL;
583
584 tx_tail = NEXT_TX(tx_tail);
585 }
586
587 de->tx_tail = tx_tail;
588
589 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
590 netif_wake_queue(de->dev);
591 }
592
593 static int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
594 {
595 struct de_private *de = dev->priv;
596 unsigned int entry, tx_free;
597 u32 mapping, len, flags = FirstFrag | LastFrag;
598 struct de_desc *txd;
599
600 spin_lock_irq(&de->lock);
601
602 tx_free = TX_BUFFS_AVAIL(de);
603 if (tx_free == 0) {
604 netif_stop_queue(dev);
605 spin_unlock_irq(&de->lock);
606 return 1;
607 }
608 tx_free--;
609
610 entry = de->tx_head;
611
612 txd = &de->tx_ring[entry];
613
614 len = skb->len;
615 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
616 if (entry == (DE_TX_RING_SIZE - 1))
617 flags |= RingEnd;
618 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
619 flags |= TxSwInt;
620 flags |= len;
621 txd->opts2 = cpu_to_le32(flags);
622 txd->addr1 = cpu_to_le32(mapping);
623
624 de->tx_skb[entry].skb = skb;
625 de->tx_skb[entry].mapping = mapping;
626 wmb();
627
628 txd->opts1 = cpu_to_le32(DescOwn);
629 wmb();
630
631 de->tx_head = NEXT_TX(entry);
632 if (netif_msg_tx_queued(de))
633 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
634 dev->name, entry, skb->len);
635
636 if (tx_free == 0)
637 netif_stop_queue(dev);
638
639 spin_unlock_irq(&de->lock);
640
641 /* Trigger an immediate transmit demand. */
642 dw32(TxPoll, NormalTxPoll);
643 dev->trans_start = jiffies;
644
645 return 0;
646 }
647
648 /* Set or clear the multicast filter for this adaptor.
649 Note that we only use exclusion around actually queueing the
650 new frame, not around filling de->setup_frame. This is non-deterministic
651 when re-entered but still correct. */
652
653 #undef set_bit_le
654 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
655
656 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
657 {
658 struct de_private *de = dev->priv;
659 u16 hash_table[32];
660 struct dev_mc_list *mclist;
661 int i;
662 u16 *eaddrs;
663
664 memset(hash_table, 0, sizeof(hash_table));
665 set_bit_le(255, hash_table); /* Broadcast entry */
666 /* This should work on big-endian machines as well. */
667 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
668 i++, mclist = mclist->next) {
669 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
670
671 set_bit_le(index, hash_table);
672
673 for (i = 0; i < 32; i++) {
674 *setup_frm++ = hash_table[i];
675 *setup_frm++ = hash_table[i];
676 }
677 setup_frm = &de->setup_frame[13*6];
678 }
679
680 /* Fill the final entry with our physical address. */
681 eaddrs = (u16 *)dev->dev_addr;
682 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
683 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
684 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
685 }
686
687 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
688 {
689 struct de_private *de = dev->priv;
690 struct dev_mc_list *mclist;
691 int i;
692 u16 *eaddrs;
693
694 /* We have <= 14 addresses so we can use the wonderful
695 16 address perfect filtering of the Tulip. */
696 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
697 i++, mclist = mclist->next) {
698 eaddrs = (u16 *)mclist->dmi_addr;
699 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
700 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
701 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
702 }
703 /* Fill the unused entries with the broadcast address. */
704 memset(setup_frm, 0xff, (15-i)*12);
705 setup_frm = &de->setup_frame[15*6];
706
707 /* Fill the final entry with our physical address. */
708 eaddrs = (u16 *)dev->dev_addr;
709 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
710 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
711 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
712 }
713
714
715 static void __de_set_rx_mode (struct net_device *dev)
716 {
717 struct de_private *de = dev->priv;
718 u32 macmode;
719 unsigned int entry;
720 u32 mapping;
721 struct de_desc *txd;
722 struct de_desc *dummy_txd = NULL;
723
724 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
725
726 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
727 macmode |= AcceptAllMulticast | AcceptAllPhys;
728 goto out;
729 }
730
731 if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
732 /* Too many to filter well -- accept all multicasts. */
733 macmode |= AcceptAllMulticast;
734 goto out;
735 }
736
737 /* Note that only the low-address shortword of setup_frame is valid!
738 The values are doubled for big-endian architectures. */
739 if (dev->mc_count > 14) /* Must use a multicast hash table. */
740 build_setup_frame_hash (de->setup_frame, dev);
741 else
742 build_setup_frame_perfect (de->setup_frame, dev);
743
744 /*
745 * Now add this frame to the Tx list.
746 */
747
748 entry = de->tx_head;
749
750 /* Avoid a chip errata by prefixing a dummy entry. */
751 if (entry != 0) {
752 de->tx_skb[entry].skb = DE_DUMMY_SKB;
753
754 dummy_txd = &de->tx_ring[entry];
755 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
756 cpu_to_le32(RingEnd) : 0;
757 dummy_txd->addr1 = 0;
758
759 /* Must set DescOwned later to avoid race with chip */
760
761 entry = NEXT_TX(entry);
762 }
763
764 de->tx_skb[entry].skb = DE_SETUP_SKB;
765 de->tx_skb[entry].mapping = mapping =
766 pci_map_single (de->pdev, de->setup_frame,
767 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
768
769 /* Put the setup frame on the Tx list. */
770 txd = &de->tx_ring[entry];
771 if (entry == (DE_TX_RING_SIZE - 1))
772 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
773 else
774 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
775 txd->addr1 = cpu_to_le32(mapping);
776 wmb();
777
778 txd->opts1 = cpu_to_le32(DescOwn);
779 wmb();
780
781 if (dummy_txd) {
782 dummy_txd->opts1 = cpu_to_le32(DescOwn);
783 wmb();
784 }
785
786 de->tx_head = NEXT_TX(entry);
787
788 if (TX_BUFFS_AVAIL(de) == 0)
789 netif_stop_queue(dev);
790
791 /* Trigger an immediate transmit demand. */
792 dw32(TxPoll, NormalTxPoll);
793
794 out:
795 if (macmode != dr32(MacMode))
796 dw32(MacMode, macmode);
797 }
798
799 static void de_set_rx_mode (struct net_device *dev)
800 {
801 unsigned long flags;
802 struct de_private *de = dev->priv;
803
804 spin_lock_irqsave (&de->lock, flags);
805 __de_set_rx_mode(dev);
806 spin_unlock_irqrestore (&de->lock, flags);
807 }
808
809 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
810 {
811 if (unlikely(rx_missed & RxMissedOver))
812 de->net_stats.rx_missed_errors += RxMissedMask;
813 else
814 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
815 }
816
817 static void __de_get_stats(struct de_private *de)
818 {
819 u32 tmp = dr32(RxMissed); /* self-clearing */
820
821 de_rx_missed(de, tmp);
822 }
823
824 static struct net_device_stats *de_get_stats(struct net_device *dev)
825 {
826 struct de_private *de = dev->priv;
827
828 /* The chip only need report frame silently dropped. */
829 spin_lock_irq(&de->lock);
830 if (netif_running(dev) && netif_device_present(dev))
831 __de_get_stats(de);
832 spin_unlock_irq(&de->lock);
833
834 return &de->net_stats;
835 }
836
837 static inline int de_is_running (struct de_private *de)
838 {
839 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
840 }
841
842 static void de_stop_rxtx (struct de_private *de)
843 {
844 u32 macmode;
845 unsigned int work = 1000;
846
847 macmode = dr32(MacMode);
848 if (macmode & RxTx) {
849 dw32(MacMode, macmode & ~RxTx);
850 dr32(MacMode);
851 }
852
853 while (--work > 0) {
854 if (!de_is_running(de))
855 return;
856 cpu_relax();
857 }
858
859 printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
860 }
861
862 static inline void de_start_rxtx (struct de_private *de)
863 {
864 u32 macmode;
865
866 macmode = dr32(MacMode);
867 if ((macmode & RxTx) != RxTx) {
868 dw32(MacMode, macmode | RxTx);
869 dr32(MacMode);
870 }
871 }
872
873 static void de_stop_hw (struct de_private *de)
874 {
875
876 udelay(5);
877 dw32(IntrMask, 0);
878
879 de_stop_rxtx(de);
880
881 dw32(MacStatus, dr32(MacStatus));
882
883 udelay(10);
884
885 de->rx_tail = 0;
886 de->tx_head = de->tx_tail = 0;
887 }
888
889 static void de_link_up(struct de_private *de)
890 {
891 if (!netif_carrier_ok(de->dev)) {
892 netif_carrier_on(de->dev);
893 if (netif_msg_link(de))
894 printk(KERN_INFO "%s: link up, media %s\n",
895 de->dev->name, media_name[de->media_type]);
896 }
897 }
898
899 static void de_link_down(struct de_private *de)
900 {
901 if (netif_carrier_ok(de->dev)) {
902 netif_carrier_off(de->dev);
903 if (netif_msg_link(de))
904 printk(KERN_INFO "%s: link down\n", de->dev->name);
905 }
906 }
907
908 static void de_set_media (struct de_private *de)
909 {
910 unsigned media = de->media_type;
911 u32 macmode = dr32(MacMode);
912
913 BUG_ON(de_is_running(de));
914
915 if (de->de21040)
916 dw32(CSR11, FULL_DUPLEX_MAGIC);
917 dw32(CSR13, 0); /* Reset phy */
918 dw32(CSR14, de->media[media].csr14);
919 dw32(CSR15, de->media[media].csr15);
920 dw32(CSR13, de->media[media].csr13);
921
922 /* must delay 10ms before writing to other registers,
923 * especially CSR6
924 */
925 mdelay(10);
926
927 if (media == DE_MEDIA_TP_FD)
928 macmode |= FullDuplex;
929 else
930 macmode &= ~FullDuplex;
931
932 if (netif_msg_link(de)) {
933 printk(KERN_INFO "%s: set link %s\n"
934 KERN_INFO "%s: mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
935 KERN_INFO "%s: set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
936 de->dev->name, media_name[media],
937 de->dev->name, dr32(MacMode), dr32(SIAStatus),
938 dr32(CSR13), dr32(CSR14), dr32(CSR15),
939 de->dev->name, macmode, de->media[media].csr13,
940 de->media[media].csr14, de->media[media].csr15);
941 }
942 if (macmode != dr32(MacMode))
943 dw32(MacMode, macmode);
944 }
945
946 static void de_next_media (struct de_private *de, u32 *media,
947 unsigned int n_media)
948 {
949 unsigned int i;
950
951 for (i = 0; i < n_media; i++) {
952 if (de_ok_to_advertise(de, media[i])) {
953 de->media_type = media[i];
954 return;
955 }
956 }
957 }
958
959 static void de21040_media_timer (unsigned long data)
960 {
961 struct de_private *de = (struct de_private *) data;
962 struct net_device *dev = de->dev;
963 u32 status = dr32(SIAStatus);
964 unsigned int carrier;
965 unsigned long flags;
966
967 carrier = (status & NetCxnErr) ? 0 : 1;
968
969 if (carrier) {
970 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
971 goto no_link_yet;
972
973 de->media_timer.expires = jiffies + DE_TIMER_LINK;
974 add_timer(&de->media_timer);
975 if (!netif_carrier_ok(dev))
976 de_link_up(de);
977 else
978 if (netif_msg_timer(de))
979 printk(KERN_INFO "%s: %s link ok, status %x\n",
980 dev->name, media_name[de->media_type],
981 status);
982 return;
983 }
984
985 de_link_down(de);
986
987 if (de->media_lock)
988 return;
989
990 if (de->media_type == DE_MEDIA_AUI) {
991 u32 next_state = DE_MEDIA_TP;
992 de_next_media(de, &next_state, 1);
993 } else {
994 u32 next_state = DE_MEDIA_AUI;
995 de_next_media(de, &next_state, 1);
996 }
997
998 spin_lock_irqsave(&de->lock, flags);
999 de_stop_rxtx(de);
1000 spin_unlock_irqrestore(&de->lock, flags);
1001 de_set_media(de);
1002 de_start_rxtx(de);
1003
1004 no_link_yet:
1005 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1006 add_timer(&de->media_timer);
1007
1008 if (netif_msg_timer(de))
1009 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1010 dev->name, media_name[de->media_type], status);
1011 }
1012
1013 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1014 {
1015 switch (new_media) {
1016 case DE_MEDIA_TP_AUTO:
1017 if (!(de->media_advertise & ADVERTISED_Autoneg))
1018 return 0;
1019 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1020 return 0;
1021 break;
1022 case DE_MEDIA_BNC:
1023 if (!(de->media_advertise & ADVERTISED_BNC))
1024 return 0;
1025 break;
1026 case DE_MEDIA_AUI:
1027 if (!(de->media_advertise & ADVERTISED_AUI))
1028 return 0;
1029 break;
1030 case DE_MEDIA_TP:
1031 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1032 return 0;
1033 break;
1034 case DE_MEDIA_TP_FD:
1035 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1036 return 0;
1037 break;
1038 }
1039
1040 return 1;
1041 }
1042
1043 static void de21041_media_timer (unsigned long data)
1044 {
1045 struct de_private *de = (struct de_private *) data;
1046 struct net_device *dev = de->dev;
1047 u32 status = dr32(SIAStatus);
1048 unsigned int carrier;
1049 unsigned long flags;
1050
1051 carrier = (status & NetCxnErr) ? 0 : 1;
1052
1053 if (carrier) {
1054 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1055 de->media_type == DE_MEDIA_TP ||
1056 de->media_type == DE_MEDIA_TP_FD) &&
1057 (status & LinkFailStatus))
1058 goto no_link_yet;
1059
1060 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1061 add_timer(&de->media_timer);
1062 if (!netif_carrier_ok(dev))
1063 de_link_up(de);
1064 else
1065 if (netif_msg_timer(de))
1066 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1067 dev->name, media_name[de->media_type],
1068 dr32(MacMode), status);
1069 return;
1070 }
1071
1072 de_link_down(de);
1073
1074 /* if media type locked, don't switch media */
1075 if (de->media_lock)
1076 goto set_media;
1077
1078 /* if activity detected, use that as hint for new media type */
1079 if (status & NonselPortActive) {
1080 unsigned int have_media = 1;
1081
1082 /* if AUI/BNC selected, then activity is on TP port */
1083 if (de->media_type == DE_MEDIA_AUI ||
1084 de->media_type == DE_MEDIA_BNC) {
1085 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1086 de->media_type = DE_MEDIA_TP_AUTO;
1087 else
1088 have_media = 0;
1089 }
1090
1091 /* TP selected. If there is only TP and BNC, then it's BNC */
1092 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1093 de_ok_to_advertise(de, DE_MEDIA_BNC))
1094 de->media_type = DE_MEDIA_BNC;
1095
1096 /* TP selected. If there is only TP and AUI, then it's AUI */
1097 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1098 de_ok_to_advertise(de, DE_MEDIA_AUI))
1099 de->media_type = DE_MEDIA_AUI;
1100
1101 /* otherwise, ignore the hint */
1102 else
1103 have_media = 0;
1104
1105 if (have_media)
1106 goto set_media;
1107 }
1108
1109 /*
1110 * Absent or ambiguous activity hint, move to next advertised
1111 * media state. If de->media_type is left unchanged, this
1112 * simply resets the PHY and reloads the current media settings.
1113 */
1114 if (de->media_type == DE_MEDIA_AUI) {
1115 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1116 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1117 } else if (de->media_type == DE_MEDIA_BNC) {
1118 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1119 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1120 } else {
1121 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1122 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1123 }
1124
1125 set_media:
1126 spin_lock_irqsave(&de->lock, flags);
1127 de_stop_rxtx(de);
1128 spin_unlock_irqrestore(&de->lock, flags);
1129 de_set_media(de);
1130 de_start_rxtx(de);
1131
1132 no_link_yet:
1133 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1134 add_timer(&de->media_timer);
1135
1136 if (netif_msg_timer(de))
1137 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1138 dev->name, media_name[de->media_type], status);
1139 }
1140
1141 static void de_media_interrupt (struct de_private *de, u32 status)
1142 {
1143 if (status & LinkPass) {
1144 de_link_up(de);
1145 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1146 return;
1147 }
1148
1149 BUG_ON(!(status & LinkFail));
1150
1151 if (netif_carrier_ok(de->dev)) {
1152 de_link_down(de);
1153 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1154 }
1155 }
1156
1157 static int de_reset_mac (struct de_private *de)
1158 {
1159 u32 status, tmp;
1160
1161 /*
1162 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1163 * in this area.
1164 */
1165
1166 if (dr32(BusMode) == 0xffffffff)
1167 return -EBUSY;
1168
1169 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1170 dw32 (BusMode, CmdReset);
1171 mdelay (1);
1172
1173 dw32 (BusMode, de_bus_mode);
1174 mdelay (1);
1175
1176 for (tmp = 0; tmp < 5; tmp++) {
1177 dr32 (BusMode);
1178 mdelay (1);
1179 }
1180
1181 mdelay (1);
1182
1183 status = dr32(MacStatus);
1184 if (status & (RxState | TxState))
1185 return -EBUSY;
1186 if (status == 0xffffffff)
1187 return -ENODEV;
1188 return 0;
1189 }
1190
1191 static void de_adapter_wake (struct de_private *de)
1192 {
1193 u32 pmctl;
1194
1195 if (de->de21040)
1196 return;
1197
1198 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1199 if (pmctl & PM_Mask) {
1200 pmctl &= ~PM_Mask;
1201 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1202
1203 /* de4x5.c delays, so we do too */
1204 msleep(10);
1205 }
1206 }
1207
1208 static void de_adapter_sleep (struct de_private *de)
1209 {
1210 u32 pmctl;
1211
1212 if (de->de21040)
1213 return;
1214
1215 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1216 pmctl |= PM_Sleep;
1217 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1218 }
1219
1220 static int de_init_hw (struct de_private *de)
1221 {
1222 struct net_device *dev = de->dev;
1223 u32 macmode;
1224 int rc;
1225
1226 de_adapter_wake(de);
1227
1228 macmode = dr32(MacMode) & ~MacModeClear;
1229
1230 rc = de_reset_mac(de);
1231 if (rc)
1232 return rc;
1233
1234 de_set_media(de); /* reset phy */
1235
1236 dw32(RxRingAddr, de->ring_dma);
1237 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1238
1239 dw32(MacMode, RxTx | macmode);
1240
1241 dr32(RxMissed); /* self-clearing */
1242
1243 dw32(IntrMask, de_intr_mask);
1244
1245 de_set_rx_mode(dev);
1246
1247 return 0;
1248 }
1249
1250 static int de_refill_rx (struct de_private *de)
1251 {
1252 unsigned i;
1253
1254 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1255 struct sk_buff *skb;
1256
1257 skb = dev_alloc_skb(de->rx_buf_sz);
1258 if (!skb)
1259 goto err_out;
1260
1261 skb->dev = de->dev;
1262
1263 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1264 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1265 de->rx_skb[i].skb = skb;
1266
1267 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1268 if (i == (DE_RX_RING_SIZE - 1))
1269 de->rx_ring[i].opts2 =
1270 cpu_to_le32(RingEnd | de->rx_buf_sz);
1271 else
1272 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1273 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1274 de->rx_ring[i].addr2 = 0;
1275 }
1276
1277 return 0;
1278
1279 err_out:
1280 de_clean_rings(de);
1281 return -ENOMEM;
1282 }
1283
1284 static int de_init_rings (struct de_private *de)
1285 {
1286 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1287 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1288
1289 de->rx_tail = 0;
1290 de->tx_head = de->tx_tail = 0;
1291
1292 return de_refill_rx (de);
1293 }
1294
1295 static int de_alloc_rings (struct de_private *de)
1296 {
1297 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1298 if (!de->rx_ring)
1299 return -ENOMEM;
1300 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1301 return de_init_rings(de);
1302 }
1303
1304 static void de_clean_rings (struct de_private *de)
1305 {
1306 unsigned i;
1307
1308 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1309 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1310 wmb();
1311 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1312 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1313 wmb();
1314
1315 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1316 if (de->rx_skb[i].skb) {
1317 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1318 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1319 dev_kfree_skb(de->rx_skb[i].skb);
1320 }
1321 }
1322
1323 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1324 struct sk_buff *skb = de->tx_skb[i].skb;
1325 if ((skb) && (skb != DE_DUMMY_SKB)) {
1326 if (skb != DE_SETUP_SKB) {
1327 de->net_stats.tx_dropped++;
1328 pci_unmap_single(de->pdev,
1329 de->tx_skb[i].mapping,
1330 skb->len, PCI_DMA_TODEVICE);
1331 dev_kfree_skb(skb);
1332 } else {
1333 pci_unmap_single(de->pdev,
1334 de->tx_skb[i].mapping,
1335 sizeof(de->setup_frame),
1336 PCI_DMA_TODEVICE);
1337 }
1338 }
1339 }
1340
1341 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1342 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1343 }
1344
1345 static void de_free_rings (struct de_private *de)
1346 {
1347 de_clean_rings(de);
1348 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1349 de->rx_ring = NULL;
1350 de->tx_ring = NULL;
1351 }
1352
1353 static int de_open (struct net_device *dev)
1354 {
1355 struct de_private *de = dev->priv;
1356 int rc;
1357
1358 if (netif_msg_ifup(de))
1359 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1360
1361 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1362
1363 rc = de_alloc_rings(de);
1364 if (rc) {
1365 printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
1366 dev->name, rc);
1367 return rc;
1368 }
1369
1370 dw32(IntrMask, 0);
1371
1372 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1373 if (rc) {
1374 printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
1375 dev->name, dev->irq, rc);
1376 goto err_out_free;
1377 }
1378
1379 rc = de_init_hw(de);
1380 if (rc) {
1381 printk(KERN_ERR "%s: h/w init failure, err=%d\n",
1382 dev->name, rc);
1383 goto err_out_free_irq;
1384 }
1385
1386 netif_start_queue(dev);
1387 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1388
1389 return 0;
1390
1391 err_out_free_irq:
1392 free_irq(dev->irq, dev);
1393 err_out_free:
1394 de_free_rings(de);
1395 return rc;
1396 }
1397
1398 static int de_close (struct net_device *dev)
1399 {
1400 struct de_private *de = dev->priv;
1401 unsigned long flags;
1402
1403 if (netif_msg_ifdown(de))
1404 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1405
1406 del_timer_sync(&de->media_timer);
1407
1408 spin_lock_irqsave(&de->lock, flags);
1409 de_stop_hw(de);
1410 netif_stop_queue(dev);
1411 netif_carrier_off(dev);
1412 spin_unlock_irqrestore(&de->lock, flags);
1413
1414 free_irq(dev->irq, dev);
1415
1416 de_free_rings(de);
1417 de_adapter_sleep(de);
1418 pci_disable_device(de->pdev);
1419 return 0;
1420 }
1421
1422 static void de_tx_timeout (struct net_device *dev)
1423 {
1424 struct de_private *de = dev->priv;
1425
1426 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1427 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1428 de->rx_tail, de->tx_head, de->tx_tail);
1429
1430 del_timer_sync(&de->media_timer);
1431
1432 disable_irq(dev->irq);
1433 spin_lock_irq(&de->lock);
1434
1435 de_stop_hw(de);
1436 netif_stop_queue(dev);
1437 netif_carrier_off(dev);
1438
1439 spin_unlock_irq(&de->lock);
1440 enable_irq(dev->irq);
1441
1442 /* Update the error counts. */
1443 __de_get_stats(de);
1444
1445 synchronize_irq(dev->irq);
1446 de_clean_rings(de);
1447
1448 de_init_rings(de);
1449
1450 de_init_hw(de);
1451
1452 netif_wake_queue(dev);
1453 }
1454
1455 static void __de_get_regs(struct de_private *de, u8 *buf)
1456 {
1457 int i;
1458 u32 *rbuf = (u32 *)buf;
1459
1460 /* read all CSRs */
1461 for (i = 0; i < DE_NUM_REGS; i++)
1462 rbuf[i] = dr32(i * 8);
1463
1464 /* handle self-clearing RxMissed counter, CSR8 */
1465 de_rx_missed(de, rbuf[8]);
1466 }
1467
1468 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1469 {
1470 ecmd->supported = de->media_supported;
1471 ecmd->transceiver = XCVR_INTERNAL;
1472 ecmd->phy_address = 0;
1473 ecmd->advertising = de->media_advertise;
1474
1475 switch (de->media_type) {
1476 case DE_MEDIA_AUI:
1477 ecmd->port = PORT_AUI;
1478 ecmd->speed = 5;
1479 break;
1480 case DE_MEDIA_BNC:
1481 ecmd->port = PORT_BNC;
1482 ecmd->speed = 2;
1483 break;
1484 default:
1485 ecmd->port = PORT_TP;
1486 ecmd->speed = SPEED_10;
1487 break;
1488 }
1489
1490 if (dr32(MacMode) & FullDuplex)
1491 ecmd->duplex = DUPLEX_FULL;
1492 else
1493 ecmd->duplex = DUPLEX_HALF;
1494
1495 if (de->media_lock)
1496 ecmd->autoneg = AUTONEG_DISABLE;
1497 else
1498 ecmd->autoneg = AUTONEG_ENABLE;
1499
1500 /* ignore maxtxpkt, maxrxpkt for now */
1501
1502 return 0;
1503 }
1504
1505 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1506 {
1507 u32 new_media;
1508 unsigned int media_lock;
1509
1510 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1511 return -EINVAL;
1512 if (de->de21040 && ecmd->speed == 2)
1513 return -EINVAL;
1514 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1515 return -EINVAL;
1516 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1517 return -EINVAL;
1518 if (de->de21040 && ecmd->port == PORT_BNC)
1519 return -EINVAL;
1520 if (ecmd->transceiver != XCVR_INTERNAL)
1521 return -EINVAL;
1522 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1523 return -EINVAL;
1524 if (ecmd->advertising & ~de->media_supported)
1525 return -EINVAL;
1526 if (ecmd->autoneg == AUTONEG_ENABLE &&
1527 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1528 return -EINVAL;
1529
1530 switch (ecmd->port) {
1531 case PORT_AUI:
1532 new_media = DE_MEDIA_AUI;
1533 if (!(ecmd->advertising & ADVERTISED_AUI))
1534 return -EINVAL;
1535 break;
1536 case PORT_BNC:
1537 new_media = DE_MEDIA_BNC;
1538 if (!(ecmd->advertising & ADVERTISED_BNC))
1539 return -EINVAL;
1540 break;
1541 default:
1542 if (ecmd->autoneg == AUTONEG_ENABLE)
1543 new_media = DE_MEDIA_TP_AUTO;
1544 else if (ecmd->duplex == DUPLEX_FULL)
1545 new_media = DE_MEDIA_TP_FD;
1546 else
1547 new_media = DE_MEDIA_TP;
1548 if (!(ecmd->advertising & ADVERTISED_TP))
1549 return -EINVAL;
1550 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1551 return -EINVAL;
1552 break;
1553 }
1554
1555 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1556
1557 if ((new_media == de->media_type) &&
1558 (media_lock == de->media_lock) &&
1559 (ecmd->advertising == de->media_advertise))
1560 return 0; /* nothing to change */
1561
1562 de_link_down(de);
1563 de_stop_rxtx(de);
1564
1565 de->media_type = new_media;
1566 de->media_lock = media_lock;
1567 de->media_advertise = ecmd->advertising;
1568 de_set_media(de);
1569
1570 return 0;
1571 }
1572
1573 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1574 {
1575 struct de_private *de = dev->priv;
1576
1577 strcpy (info->driver, DRV_NAME);
1578 strcpy (info->version, DRV_VERSION);
1579 strcpy (info->bus_info, pci_name(de->pdev));
1580 info->eedump_len = DE_EEPROM_SIZE;
1581 }
1582
1583 static int de_get_regs_len(struct net_device *dev)
1584 {
1585 return DE_REGS_SIZE;
1586 }
1587
1588 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1589 {
1590 struct de_private *de = dev->priv;
1591 int rc;
1592
1593 spin_lock_irq(&de->lock);
1594 rc = __de_get_settings(de, ecmd);
1595 spin_unlock_irq(&de->lock);
1596
1597 return rc;
1598 }
1599
1600 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1601 {
1602 struct de_private *de = dev->priv;
1603 int rc;
1604
1605 spin_lock_irq(&de->lock);
1606 rc = __de_set_settings(de, ecmd);
1607 spin_unlock_irq(&de->lock);
1608
1609 return rc;
1610 }
1611
1612 static u32 de_get_msglevel(struct net_device *dev)
1613 {
1614 struct de_private *de = dev->priv;
1615
1616 return de->msg_enable;
1617 }
1618
1619 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1620 {
1621 struct de_private *de = dev->priv;
1622
1623 de->msg_enable = msglvl;
1624 }
1625
1626 static int de_get_eeprom(struct net_device *dev,
1627 struct ethtool_eeprom *eeprom, u8 *data)
1628 {
1629 struct de_private *de = dev->priv;
1630
1631 if (!de->ee_data)
1632 return -EOPNOTSUPP;
1633 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1634 (eeprom->len != DE_EEPROM_SIZE))
1635 return -EINVAL;
1636 memcpy(data, de->ee_data, eeprom->len);
1637
1638 return 0;
1639 }
1640
1641 static int de_nway_reset(struct net_device *dev)
1642 {
1643 struct de_private *de = dev->priv;
1644 u32 status;
1645
1646 if (de->media_type != DE_MEDIA_TP_AUTO)
1647 return -EINVAL;
1648 if (netif_carrier_ok(de->dev))
1649 de_link_down(de);
1650
1651 status = dr32(SIAStatus);
1652 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1653 if (netif_msg_link(de))
1654 printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
1655 de->dev->name, status, dr32(SIAStatus));
1656 return 0;
1657 }
1658
1659 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1660 void *data)
1661 {
1662 struct de_private *de = dev->priv;
1663
1664 regs->version = (DE_REGS_VER << 2) | de->de21040;
1665
1666 spin_lock_irq(&de->lock);
1667 __de_get_regs(de, data);
1668 spin_unlock_irq(&de->lock);
1669 }
1670
1671 static const struct ethtool_ops de_ethtool_ops = {
1672 .get_link = ethtool_op_get_link,
1673 .get_drvinfo = de_get_drvinfo,
1674 .get_regs_len = de_get_regs_len,
1675 .get_settings = de_get_settings,
1676 .set_settings = de_set_settings,
1677 .get_msglevel = de_get_msglevel,
1678 .set_msglevel = de_set_msglevel,
1679 .get_eeprom = de_get_eeprom,
1680 .nway_reset = de_nway_reset,
1681 .get_regs = de_get_regs,
1682 };
1683
1684 static void __devinit de21040_get_mac_address (struct de_private *de)
1685 {
1686 unsigned i;
1687
1688 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1689
1690 for (i = 0; i < 6; i++) {
1691 int value, boguscnt = 100000;
1692 do
1693 value = dr32(ROMCmd);
1694 while (value < 0 && --boguscnt > 0);
1695 de->dev->dev_addr[i] = value;
1696 udelay(1);
1697 if (boguscnt <= 0)
1698 printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
1699 }
1700 }
1701
1702 static void __devinit de21040_get_media_info(struct de_private *de)
1703 {
1704 unsigned int i;
1705
1706 de->media_type = DE_MEDIA_TP;
1707 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1708 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1709 de->media_advertise = de->media_supported;
1710
1711 for (i = 0; i < DE_MAX_MEDIA; i++) {
1712 switch (i) {
1713 case DE_MEDIA_AUI:
1714 case DE_MEDIA_TP:
1715 case DE_MEDIA_TP_FD:
1716 de->media[i].type = i;
1717 de->media[i].csr13 = t21040_csr13[i];
1718 de->media[i].csr14 = t21040_csr14[i];
1719 de->media[i].csr15 = t21040_csr15[i];
1720 break;
1721 default:
1722 de->media[i].type = DE_MEDIA_INVALID;
1723 break;
1724 }
1725 }
1726 }
1727
1728 /* Note: this routine returns extra data bits for size detection. */
1729 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1730 {
1731 int i;
1732 unsigned retval = 0;
1733 void __iomem *ee_addr = regs + ROMCmd;
1734 int read_cmd = location | (EE_READ_CMD << addr_len);
1735
1736 writel(EE_ENB & ~EE_CS, ee_addr);
1737 writel(EE_ENB, ee_addr);
1738
1739 /* Shift the read command bits out. */
1740 for (i = 4 + addr_len; i >= 0; i--) {
1741 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1742 writel(EE_ENB | dataval, ee_addr);
1743 readl(ee_addr);
1744 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1745 readl(ee_addr);
1746 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1747 }
1748 writel(EE_ENB, ee_addr);
1749 readl(ee_addr);
1750
1751 for (i = 16; i > 0; i--) {
1752 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1753 readl(ee_addr);
1754 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1755 writel(EE_ENB, ee_addr);
1756 readl(ee_addr);
1757 }
1758
1759 /* Terminate the EEPROM access. */
1760 writel(EE_ENB & ~EE_CS, ee_addr);
1761 return retval;
1762 }
1763
1764 static void __devinit de21041_get_srom_info (struct de_private *de)
1765 {
1766 unsigned i, sa_offset = 0, ofs;
1767 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1768 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1769 struct de_srom_info_leaf *il;
1770 void *bufp;
1771
1772 /* download entire eeprom */
1773 for (i = 0; i < DE_EEPROM_WORDS; i++)
1774 ((__le16 *)ee_data)[i] =
1775 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1776
1777 /* DEC now has a specification but early board makers
1778 just put the address in the first EEPROM locations. */
1779 /* This does memcmp(eedata, eedata+16, 8) */
1780
1781 #ifndef CONFIG_MIPS_COBALT
1782
1783 for (i = 0; i < 8; i ++)
1784 if (ee_data[i] != ee_data[16+i])
1785 sa_offset = 20;
1786
1787 #endif
1788
1789 /* store MAC address */
1790 for (i = 0; i < 6; i ++)
1791 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1792
1793 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1794 ofs = ee_data[SROMC0InfoLeaf];
1795 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1796 goto bad_srom;
1797
1798 /* get pointer to info leaf */
1799 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1800
1801 /* paranoia checks */
1802 if (il->n_blocks == 0)
1803 goto bad_srom;
1804 if ((sizeof(ee_data) - ofs) <
1805 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1806 goto bad_srom;
1807
1808 /* get default media type */
1809 switch (DE_UNALIGNED_16(&il->default_media)) {
1810 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1811 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1812 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1813 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1814 }
1815
1816 if (netif_msg_probe(de))
1817 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1818 de->board_idx, ofs,
1819 media_name[de->media_type]);
1820
1821 /* init SIA register values to defaults */
1822 for (i = 0; i < DE_MAX_MEDIA; i++) {
1823 de->media[i].type = DE_MEDIA_INVALID;
1824 de->media[i].csr13 = 0xffff;
1825 de->media[i].csr14 = 0xffff;
1826 de->media[i].csr15 = 0xffff;
1827 }
1828
1829 /* parse media blocks to see what medias are supported,
1830 * and if any custom CSR values are provided
1831 */
1832 bufp = ((void *)il) + sizeof(*il);
1833 for (i = 0; i < il->n_blocks; i++) {
1834 struct de_srom_media_block *ib = bufp;
1835 unsigned idx;
1836
1837 /* index based on media type in media block */
1838 switch(ib->opts & MediaBlockMask) {
1839 case 0: /* 10baseT */
1840 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1841 | SUPPORTED_Autoneg;
1842 idx = DE_MEDIA_TP;
1843 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1844 break;
1845 case 1: /* BNC */
1846 de->media_supported |= SUPPORTED_BNC;
1847 idx = DE_MEDIA_BNC;
1848 break;
1849 case 2: /* AUI */
1850 de->media_supported |= SUPPORTED_AUI;
1851 idx = DE_MEDIA_AUI;
1852 break;
1853 case 4: /* 10baseT-FD */
1854 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1855 | SUPPORTED_Autoneg;
1856 idx = DE_MEDIA_TP_FD;
1857 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1858 break;
1859 default:
1860 goto bad_srom;
1861 }
1862
1863 de->media[idx].type = idx;
1864
1865 if (netif_msg_probe(de))
1866 printk(KERN_INFO "de%d: media block #%u: %s",
1867 de->board_idx, i,
1868 media_name[de->media[idx].type]);
1869
1870 bufp += sizeof (ib->opts);
1871
1872 if (ib->opts & MediaCustomCSRs) {
1873 de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
1874 de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1875 de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
1876 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1877 sizeof(ib->csr15);
1878
1879 if (netif_msg_probe(de))
1880 printk(" (%x,%x,%x)\n",
1881 de->media[idx].csr13,
1882 de->media[idx].csr14,
1883 de->media[idx].csr15);
1884
1885 } else if (netif_msg_probe(de))
1886 printk("\n");
1887
1888 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1889 break;
1890 }
1891
1892 de->media_advertise = de->media_supported;
1893
1894 fill_defaults:
1895 /* fill in defaults, for cases where custom CSRs not used */
1896 for (i = 0; i < DE_MAX_MEDIA; i++) {
1897 if (de->media[i].csr13 == 0xffff)
1898 de->media[i].csr13 = t21041_csr13[i];
1899 if (de->media[i].csr14 == 0xffff)
1900 de->media[i].csr14 = t21041_csr14[i];
1901 if (de->media[i].csr15 == 0xffff)
1902 de->media[i].csr15 = t21041_csr15[i];
1903 }
1904
1905 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1906
1907 return;
1908
1909 bad_srom:
1910 /* for error cases, it's ok to assume we support all these */
1911 for (i = 0; i < DE_MAX_MEDIA; i++)
1912 de->media[i].type = i;
1913 de->media_supported =
1914 SUPPORTED_10baseT_Half |
1915 SUPPORTED_10baseT_Full |
1916 SUPPORTED_Autoneg |
1917 SUPPORTED_TP |
1918 SUPPORTED_AUI |
1919 SUPPORTED_BNC;
1920 goto fill_defaults;
1921 }
1922
1923 static int __devinit de_init_one (struct pci_dev *pdev,
1924 const struct pci_device_id *ent)
1925 {
1926 struct net_device *dev;
1927 struct de_private *de;
1928 int rc;
1929 void __iomem *regs;
1930 unsigned long pciaddr;
1931 static int board_idx = -1;
1932 DECLARE_MAC_BUF(mac);
1933
1934 board_idx++;
1935
1936 #ifndef MODULE
1937 if (board_idx == 0)
1938 printk("%s", version);
1939 #endif
1940
1941 /* allocate a new ethernet device structure, and fill in defaults */
1942 dev = alloc_etherdev(sizeof(struct de_private));
1943 if (!dev)
1944 return -ENOMEM;
1945
1946 SET_NETDEV_DEV(dev, &pdev->dev);
1947 dev->open = de_open;
1948 dev->stop = de_close;
1949 dev->set_multicast_list = de_set_rx_mode;
1950 dev->hard_start_xmit = de_start_xmit;
1951 dev->get_stats = de_get_stats;
1952 dev->ethtool_ops = &de_ethtool_ops;
1953 dev->tx_timeout = de_tx_timeout;
1954 dev->watchdog_timeo = TX_TIMEOUT;
1955
1956 de = dev->priv;
1957 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1958 de->pdev = pdev;
1959 de->dev = dev;
1960 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1961 de->board_idx = board_idx;
1962 spin_lock_init (&de->lock);
1963 init_timer(&de->media_timer);
1964 if (de->de21040)
1965 de->media_timer.function = de21040_media_timer;
1966 else
1967 de->media_timer.function = de21041_media_timer;
1968 de->media_timer.data = (unsigned long) de;
1969
1970 netif_carrier_off(dev);
1971 netif_stop_queue(dev);
1972
1973 /* wake up device, assign resources */
1974 rc = pci_enable_device(pdev);
1975 if (rc)
1976 goto err_out_free;
1977
1978 /* reserve PCI resources to ensure driver atomicity */
1979 rc = pci_request_regions(pdev, DRV_NAME);
1980 if (rc)
1981 goto err_out_disable;
1982
1983 /* check for invalid IRQ value */
1984 if (pdev->irq < 2) {
1985 rc = -EIO;
1986 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
1987 pdev->irq, pci_name(pdev));
1988 goto err_out_res;
1989 }
1990
1991 dev->irq = pdev->irq;
1992
1993 /* obtain and check validity of PCI I/O address */
1994 pciaddr = pci_resource_start(pdev, 1);
1995 if (!pciaddr) {
1996 rc = -EIO;
1997 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
1998 pci_name(pdev));
1999 goto err_out_res;
2000 }
2001 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2002 rc = -EIO;
2003 printk(KERN_ERR PFX "MMIO resource (%llx) too small on pci dev %s\n",
2004 (unsigned long long)pci_resource_len(pdev, 1), pci_name(pdev));
2005 goto err_out_res;
2006 }
2007
2008 /* remap CSR registers */
2009 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2010 if (!regs) {
2011 rc = -EIO;
2012 printk(KERN_ERR PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2013 (unsigned long long)pci_resource_len(pdev, 1),
2014 pciaddr, pci_name(pdev));
2015 goto err_out_res;
2016 }
2017 dev->base_addr = (unsigned long) regs;
2018 de->regs = regs;
2019
2020 de_adapter_wake(de);
2021
2022 /* make sure hardware is not running */
2023 rc = de_reset_mac(de);
2024 if (rc) {
2025 printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
2026 pci_name(pdev));
2027 goto err_out_iomap;
2028 }
2029
2030 /* get MAC address, initialize default media type and
2031 * get list of supported media
2032 */
2033 if (de->de21040) {
2034 de21040_get_mac_address(de);
2035 de21040_get_media_info(de);
2036 } else {
2037 de21041_get_srom_info(de);
2038 }
2039
2040 /* register new network interface with kernel */
2041 rc = register_netdev(dev);
2042 if (rc)
2043 goto err_out_iomap;
2044
2045 /* print info about board and interface just registered */
2046 printk (KERN_INFO "%s: %s at 0x%lx, %s, IRQ %d\n",
2047 dev->name,
2048 de->de21040 ? "21040" : "21041",
2049 dev->base_addr,
2050 print_mac(mac, dev->dev_addr),
2051 dev->irq);
2052
2053 pci_set_drvdata(pdev, dev);
2054
2055 /* enable busmastering */
2056 pci_set_master(pdev);
2057
2058 /* put adapter to sleep */
2059 de_adapter_sleep(de);
2060
2061 return 0;
2062
2063 err_out_iomap:
2064 kfree(de->ee_data);
2065 iounmap(regs);
2066 err_out_res:
2067 pci_release_regions(pdev);
2068 err_out_disable:
2069 pci_disable_device(pdev);
2070 err_out_free:
2071 free_netdev(dev);
2072 return rc;
2073 }
2074
2075 static void __devexit de_remove_one (struct pci_dev *pdev)
2076 {
2077 struct net_device *dev = pci_get_drvdata(pdev);
2078 struct de_private *de = dev->priv;
2079
2080 BUG_ON(!dev);
2081 unregister_netdev(dev);
2082 kfree(de->ee_data);
2083 iounmap(de->regs);
2084 pci_release_regions(pdev);
2085 pci_disable_device(pdev);
2086 pci_set_drvdata(pdev, NULL);
2087 free_netdev(dev);
2088 }
2089
2090 #ifdef CONFIG_PM
2091
2092 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2093 {
2094 struct net_device *dev = pci_get_drvdata (pdev);
2095 struct de_private *de = dev->priv;
2096
2097 rtnl_lock();
2098 if (netif_running (dev)) {
2099 del_timer_sync(&de->media_timer);
2100
2101 disable_irq(dev->irq);
2102 spin_lock_irq(&de->lock);
2103
2104 de_stop_hw(de);
2105 netif_stop_queue(dev);
2106 netif_device_detach(dev);
2107 netif_carrier_off(dev);
2108
2109 spin_unlock_irq(&de->lock);
2110 enable_irq(dev->irq);
2111
2112 /* Update the error counts. */
2113 __de_get_stats(de);
2114
2115 synchronize_irq(dev->irq);
2116 de_clean_rings(de);
2117
2118 de_adapter_sleep(de);
2119 pci_disable_device(pdev);
2120 } else {
2121 netif_device_detach(dev);
2122 }
2123 rtnl_unlock();
2124 return 0;
2125 }
2126
2127 static int de_resume (struct pci_dev *pdev)
2128 {
2129 struct net_device *dev = pci_get_drvdata (pdev);
2130 struct de_private *de = dev->priv;
2131 int retval = 0;
2132
2133 rtnl_lock();
2134 if (netif_device_present(dev))
2135 goto out;
2136 if (!netif_running(dev))
2137 goto out_attach;
2138 if ((retval = pci_enable_device(pdev))) {
2139 printk (KERN_ERR "%s: pci_enable_device failed in resume\n",
2140 dev->name);
2141 goto out;
2142 }
2143 de_init_hw(de);
2144 out_attach:
2145 netif_device_attach(dev);
2146 out:
2147 rtnl_unlock();
2148 return 0;
2149 }
2150
2151 #endif /* CONFIG_PM */
2152
2153 static struct pci_driver de_driver = {
2154 .name = DRV_NAME,
2155 .id_table = de_pci_tbl,
2156 .probe = de_init_one,
2157 .remove = __devexit_p(de_remove_one),
2158 #ifdef CONFIG_PM
2159 .suspend = de_suspend,
2160 .resume = de_resume,
2161 #endif
2162 };
2163
2164 static int __init de_init (void)
2165 {
2166 #ifdef MODULE
2167 printk("%s", version);
2168 #endif
2169 return pci_register_driver(&de_driver);
2170 }
2171
2172 static void __exit de_exit (void)
2173 {
2174 pci_unregister_driver (&de_driver);
2175 }
2176
2177 module_init(de_init);
2178 module_exit(de_exit);
Ubuntu combined Linux kernel mirror