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