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