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