?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / net / tulip / de2104x.c
blob71fc3d08416607832dabdb0cafda733c3d27dd21
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
60 static int debug = -1;
61 MODULE_PARM (debug, "i");
62 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
63
64 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
65 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
66 || defined(__sparc_) || defined(__ia64__) \
67 || defined(__sh__) || defined(__mips__)
68 static int rx_copybreak = 1518;
69 #else
70 static int rx_copybreak = 100;
71 #endif
72 MODULE_PARM (rx_copybreak, "i");
73 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
74
75 #define PFX DRV_NAME ": "
76
77 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
78 NETIF_MSG_PROBE | \
79 NETIF_MSG_LINK | \
80 NETIF_MSG_IFDOWN | \
81 NETIF_MSG_IFUP | \
82 NETIF_MSG_RX_ERR | \
83 NETIF_MSG_TX_ERR)
84
85 #define DE_RX_RING_SIZE 64
86 #define DE_TX_RING_SIZE 64
87 #define DE_RING_BYTES \
88 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
89 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
90 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
91 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
92 #define TX_BUFFS_AVAIL(CP) \
93 (((CP)->tx_tail <= (CP)->tx_head) ? \
94 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
95 (CP)->tx_tail - (CP)->tx_head - 1)
96
97 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
98 #define RX_OFFSET 2
99
100 #define DE_SETUP_SKB ((struct sk_buff *) 1)
101 #define DE_DUMMY_SKB ((struct sk_buff *) 2)
102 #define DE_SETUP_FRAME_WORDS 96
103 #define DE_EEPROM_WORDS 256
104 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
105 #define DE_MAX_MEDIA 5
106
107 #define DE_MEDIA_TP_AUTO 0
108 #define DE_MEDIA_BNC 1
109 #define DE_MEDIA_AUI 2
110 #define DE_MEDIA_TP 3
111 #define DE_MEDIA_TP_FD 4
112 #define DE_MEDIA_INVALID DE_MAX_MEDIA
113 #define DE_MEDIA_FIRST 0
114 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
115 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
116
117 #define DE_TIMER_LINK (60 * HZ)
118 #define DE_TIMER_NO_LINK (5 * HZ)
119
120 #define DE_NUM_REGS 16
121 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
122 #define DE_REGS_VER 1
123
124 /* Time in jiffies before concluding the transmitter is hung. */
125 #define TX_TIMEOUT (6*HZ)
126
127 #define DE_UNALIGNED_16(a) (u16)(get_unaligned((u16 *)(a)))
128
129 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
130 to support a pre-NWay full-duplex signaling mechanism using short frames.
131 No one knows what it should be, but if left at its default value some
132 10base2(!) packets trigger a full-duplex-request interrupt. */
133 #define FULL_DUPLEX_MAGIC 0x6969
134
135 enum {
136 /* NIC registers */
137 BusMode = 0x00,
138 TxPoll = 0x08,
139 RxPoll = 0x10,
140 RxRingAddr = 0x18,
141 TxRingAddr = 0x20,
142 MacStatus = 0x28,
143 MacMode = 0x30,
144 IntrMask = 0x38,
145 RxMissed = 0x40,
146 ROMCmd = 0x48,
147 CSR11 = 0x58,
148 SIAStatus = 0x60,
149 CSR13 = 0x68,
150 CSR14 = 0x70,
151 CSR15 = 0x78,
152 PCIPM = 0x40,
153
154 /* BusMode bits */
155 CmdReset = (1 << 0),
156 CacheAlign16 = 0x00008000,
157 BurstLen4 = 0x00000400,
158
159 /* Rx/TxPoll bits */
160 NormalTxPoll = (1 << 0),
161 NormalRxPoll = (1 << 0),
162
163 /* Tx/Rx descriptor status bits */
164 DescOwn = (1 << 31),
165 RxError = (1 << 15),
166 RxErrLong = (1 << 7),
167 RxErrCRC = (1 << 1),
168 RxErrFIFO = (1 << 0),
169 RxErrRunt = (1 << 11),
170 RxErrFrame = (1 << 14),
171 RingEnd = (1 << 25),
172 FirstFrag = (1 << 29),
173 LastFrag = (1 << 30),
174 TxError = (1 << 15),
175 TxFIFOUnder = (1 << 1),
176 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
177 TxMaxCol = (1 << 8),
178 TxOWC = (1 << 9),
179 TxJabber = (1 << 14),
180 SetupFrame = (1 << 27),
181 TxSwInt = (1 << 31),
182
183 /* MacStatus bits */
184 IntrOK = (1 << 16),
185 IntrErr = (1 << 15),
186 RxIntr = (1 << 6),
187 RxEmpty = (1 << 7),
188 TxIntr = (1 << 0),
189 TxEmpty = (1 << 2),
190 PciErr = (1 << 13),
191 TxState = (1 << 22) | (1 << 21) | (1 << 20),
192 RxState = (1 << 19) | (1 << 18) | (1 << 17),
193 LinkFail = (1 << 12),
194 LinkPass = (1 << 4),
195 RxStopped = (1 << 8),
196 TxStopped = (1 << 1),
197
198 /* MacMode bits */
199 TxEnable = (1 << 13),
200 RxEnable = (1 << 1),
201 RxTx = TxEnable | RxEnable,
202 FullDuplex = (1 << 9),
203 AcceptAllMulticast = (1 << 7),
204 AcceptAllPhys = (1 << 6),
205 BOCnt = (1 << 5),
206 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
207 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
208
209 /* ROMCmd bits */
210 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
211 EE_CS = 0x01, /* EEPROM chip select. */
212 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
213 EE_WRITE_0 = 0x01,
214 EE_WRITE_1 = 0x05,
215 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
216 EE_ENB = (0x4800 | EE_CS),
217
218 /* The EEPROM commands include the alway-set leading bit. */
219 EE_READ_CMD = 6,
220
221 /* RxMissed bits */
222 RxMissedOver = (1 << 16),
223 RxMissedMask = 0xffff,
224
225 /* SROM-related bits */
226 SROMC0InfoLeaf = 27,
227 MediaBlockMask = 0x3f,
228 MediaCustomCSRs = (1 << 6),
229
230 /* PCIPM bits */
231 PM_Sleep = (1 << 31),
232 PM_Snooze = (1 << 30),
233 PM_Mask = PM_Sleep | PM_Snooze,
234
235 /* SIAStatus bits */
236 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
237 NWayRestart = (1 << 12),
238 NonselPortActive = (1 << 9),
239 LinkFailStatus = (1 << 2),
240 NetCxnErr = (1 << 1),
241 };
242
243 static const u32 de_intr_mask =
244 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
245 LinkPass | LinkFail | PciErr;
246
247 /*
248 * Set the programmable burst length to 4 longwords for all:
249 * DMA errors result without these values. Cache align 16 long.
250 */
251 static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
252
253 struct de_srom_media_block {
254 u8 opts;
255 u16 csr13;
256 u16 csr14;
257 u16 csr15;
258 } __attribute__((packed));
259
260 struct de_srom_info_leaf {
261 u16 default_media;
262 u8 n_blocks;
263 u8 unused;
264 } __attribute__((packed));
265
266 struct de_desc {
267 u32 opts1;
268 u32 opts2;
269 u32 addr1;
270 u32 addr2;
271 };
272
273 struct media_info {
274 u16 type; /* DE_MEDIA_xxx */
275 u16 csr13;
276 u16 csr14;
277 u16 csr15;
278 };
279
280 struct ring_info {
281 struct sk_buff *skb;
282 dma_addr_t mapping;
283 };
284
285 struct de_private {
286 unsigned tx_head;
287 unsigned tx_tail;
288 unsigned rx_tail;
289
290 void *regs;
291 struct net_device *dev;
292 spinlock_t lock;
293
294 struct de_desc *rx_ring;
295 struct de_desc *tx_ring;
296 struct ring_info tx_skb[DE_TX_RING_SIZE];
297 struct ring_info rx_skb[DE_RX_RING_SIZE];
298 unsigned rx_buf_sz;
299 dma_addr_t ring_dma;
300
301 u32 msg_enable;
302
303 struct net_device_stats net_stats;
304
305 struct pci_dev *pdev;
306
307 u16 setup_frame[DE_SETUP_FRAME_WORDS];
308
309 u32 media_type;
310 u32 media_supported;
311 u32 media_advertise;
312 struct media_info media[DE_MAX_MEDIA];
313 struct timer_list media_timer;
314
315 u8 *ee_data;
316 unsigned board_idx;
317 unsigned de21040 : 1;
318 unsigned media_lock : 1;
319 };
320
321
322 static void de_set_rx_mode (struct net_device *dev);
323 static void de_tx (struct de_private *de);
324 static void de_clean_rings (struct de_private *de);
325 static void de_media_interrupt (struct de_private *de, u32 status);
326 static void de21040_media_timer (unsigned long data);
327 static void de21041_media_timer (unsigned long data);
328 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
329
330
331 static struct pci_device_id de_pci_tbl[] = {
332 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
333 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
334 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
335 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
336 { },
337 };
338 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
339
340 static const char * const media_name[DE_MAX_MEDIA] = {
341 "10baseT auto",
342 "BNC",
343 "AUI",
344 "10baseT-HD",
345 "10baseT-FD"
346 };
347
348 /* 21040 transceiver register settings:
349 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
350 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
351 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
352 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
353
354 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
355 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
356 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
357 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
358
359
360 #define dr32(reg) readl(de->regs + (reg))
361 #define dw32(reg,val) writel((val), de->regs + (reg))
362
363
364 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
365 u32 status, u32 len)
366 {
367 if (netif_msg_rx_err (de))
368 printk (KERN_DEBUG
369 "%s: rx err, slot %d status 0x%x len %d\n",
370 de->dev->name, rx_tail, status, len);
371
372 if ((status & 0x38000300) != 0x0300) {
373 /* Ingore earlier buffers. */
374 if ((status & 0xffff) != 0x7fff) {
375 if (netif_msg_rx_err(de))
376 printk(KERN_WARNING "%s: Oversized Ethernet frame "
377 "spanned multiple buffers, status %8.8x!\n",
378 de->dev->name, status);
379 de->net_stats.rx_length_errors++;
380 }
381 } else if (status & RxError) {
382 /* There was a fatal error. */
383 de->net_stats.rx_errors++; /* end of a packet.*/
384 if (status & 0x0890) de->net_stats.rx_length_errors++;
385 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
386 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
387 }
388 }
389
390 static void de_rx (struct de_private *de)
391 {
392 unsigned rx_tail = de->rx_tail;
393 unsigned rx_work = DE_RX_RING_SIZE;
394 unsigned drop = 0;
395 int rc;
396
397 while (rx_work--) {
398 u32 status, len;
399 dma_addr_t mapping;
400 struct sk_buff *skb, *copy_skb;
401 unsigned copying_skb, buflen;
402
403 skb = de->rx_skb[rx_tail].skb;
404 if (!skb)
405 BUG();
406 rmb();
407 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
408 if (status & DescOwn)
409 break;
410
411 len = ((status >> 16) & 0x7ff) - 4;
412 mapping = de->rx_skb[rx_tail].mapping;
413
414 if (unlikely(drop)) {
415 de->net_stats.rx_dropped++;
416 goto rx_next;
417 }
418
419 if (unlikely((status & 0x38008300) != 0x0300)) {
420 de_rx_err_acct(de, rx_tail, status, len);
421 goto rx_next;
422 }
423
424 copying_skb = (len <= rx_copybreak);
425
426 if (unlikely(netif_msg_rx_status(de)))
427 printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
428 de->dev->name, rx_tail, status, len,
429 copying_skb);
430
431 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
432 copy_skb = dev_alloc_skb (buflen);
433 if (unlikely(!copy_skb)) {
434 de->net_stats.rx_dropped++;
435 drop = 1;
436 rx_work = 100;
437 goto rx_next;
438 }
439 copy_skb->dev = de->dev;
440
441 if (!copying_skb) {
442 pci_unmap_single(de->pdev, mapping,
443 buflen, PCI_DMA_FROMDEVICE);
444 skb_put(skb, len);
445
446 mapping =
447 de->rx_skb[rx_tail].mapping =
448 pci_map_single(de->pdev, copy_skb->tail,
449 buflen, PCI_DMA_FROMDEVICE);
450 de->rx_skb[rx_tail].skb = copy_skb;
451 } else {
452 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
453 skb_reserve(copy_skb, RX_OFFSET);
454 memcpy(skb_put(copy_skb, len), skb->tail, len);
455
456 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
457
458 /* We'll reuse the original ring buffer. */
459 skb = copy_skb;
460 }
461
462 skb->protocol = eth_type_trans (skb, de->dev);
463
464 de->net_stats.rx_packets++;
465 de->net_stats.rx_bytes += skb->len;
466 de->dev->last_rx = jiffies;
467 rc = netif_rx (skb);
468 if (rc == NET_RX_DROP)
469 drop = 1;
470
471 rx_next:
472 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
473 if (rx_tail == (DE_RX_RING_SIZE - 1))
474 de->rx_ring[rx_tail].opts2 =
475 cpu_to_le32(RingEnd | de->rx_buf_sz);
476 else
477 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
478 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
479 rx_tail = NEXT_RX(rx_tail);
480 }
481
482 if (!rx_work)
483 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
484
485 de->rx_tail = rx_tail;
486 }
487
488 static irqreturn_t de_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
489 {
490 struct net_device *dev = dev_instance;
491 struct de_private *de = dev->priv;
492 u32 status;
493
494 status = dr32(MacStatus);
495 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
496 return IRQ_NONE;
497
498 if (netif_msg_intr(de))
499 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
500 dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
501
502 dw32(MacStatus, status);
503
504 if (status & (RxIntr | RxEmpty)) {
505 de_rx(de);
506 if (status & RxEmpty)
507 dw32(RxPoll, NormalRxPoll);
508 }
509
510 spin_lock(&de->lock);
511
512 if (status & (TxIntr | TxEmpty))
513 de_tx(de);
514
515 if (status & (LinkPass | LinkFail))
516 de_media_interrupt(de, status);
517
518 spin_unlock(&de->lock);
519
520 if (status & PciErr) {
521 u16 pci_status;
522
523 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
524 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
525 printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
526 dev->name, status, pci_status);
527 }
528
529 return IRQ_HANDLED;
530 }
531
532 static void de_tx (struct de_private *de)
533 {
534 unsigned tx_head = de->tx_head;
535 unsigned tx_tail = de->tx_tail;
536
537 while (tx_tail != tx_head) {
538 struct sk_buff *skb;
539 u32 status;
540
541 rmb();
542 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
543 if (status & DescOwn)
544 break;
545
546 skb = de->tx_skb[tx_tail].skb;
547 if (!skb)
548 BUG();
549 if (unlikely(skb == DE_DUMMY_SKB))
550 goto next;
551
552 if (unlikely(skb == DE_SETUP_SKB)) {
553 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
554 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
555 goto next;
556 }
557
558 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
559 skb->len, PCI_DMA_TODEVICE);
560
561 if (status & LastFrag) {
562 if (status & TxError) {
563 if (netif_msg_tx_err(de))
564 printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
565 de->dev->name, status);
566 de->net_stats.tx_errors++;
567 if (status & TxOWC)
568 de->net_stats.tx_window_errors++;
569 if (status & TxMaxCol)
570 de->net_stats.tx_aborted_errors++;
571 if (status & TxLinkFail)
572 de->net_stats.tx_carrier_errors++;
573 if (status & TxFIFOUnder)
574 de->net_stats.tx_fifo_errors++;
575 } else {
576 de->net_stats.tx_packets++;
577 de->net_stats.tx_bytes += skb->len;
578 if (netif_msg_tx_done(de))
579 printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
580 }
581 dev_kfree_skb_irq(skb);
582 }
583
584 next:
585 de->tx_skb[tx_tail].skb = NULL;
586
587 tx_tail = NEXT_TX(tx_tail);
588 }
589
590 de->tx_tail = tx_tail;
591
592 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
593 netif_wake_queue(de->dev);
594 }
595
596 static int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
597 {
598 struct de_private *de = dev->priv;
599 unsigned int entry, tx_free;
600 u32 mapping, len, flags = FirstFrag | LastFrag;
601 struct de_desc *txd;
602
603 spin_lock_irq(&de->lock);
604
605 tx_free = TX_BUFFS_AVAIL(de);
606 if (tx_free == 0) {
607 netif_stop_queue(dev);
608 spin_unlock_irq(&de->lock);
609 return 1;
610 }
611 tx_free--;
612
613 entry = de->tx_head;
614
615 txd = &de->tx_ring[entry];
616
617 len = skb->len;
618 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
619 if (entry == (DE_TX_RING_SIZE - 1))
620 flags |= RingEnd;
621 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
622 flags |= TxSwInt;
623 flags |= len;
624 txd->opts2 = cpu_to_le32(flags);
625 txd->addr1 = cpu_to_le32(mapping);
626
627 de->tx_skb[entry].skb = skb;
628 de->tx_skb[entry].mapping = mapping;
629 wmb();
630
631 txd->opts1 = cpu_to_le32(DescOwn);
632 wmb();
633
634 de->tx_head = NEXT_TX(entry);
635 if (netif_msg_tx_queued(de))
636 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
637 dev->name, entry, skb->len);
638
639 if (tx_free == 0)
640 netif_stop_queue(dev);
641
642 spin_unlock_irq(&de->lock);
643
644 /* Trigger an immediate transmit demand. */
645 dw32(TxPoll, NormalTxPoll);
646 dev->trans_start = jiffies;
647
648 return 0;
649 }
650
651 /* Set or clear the multicast filter for this adaptor.
652 Note that we only use exclusion around actually queueing the
653 new frame, not around filling de->setup_frame. This is non-deterministic
654 when re-entered but still correct. */
655
656 #undef set_bit_le
657 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
658
659 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
660 {
661 struct de_private *de = dev->priv;
662 u16 hash_table[32];
663 struct dev_mc_list *mclist;
664 int i;
665 u16 *eaddrs;
666
667 memset(hash_table, 0, sizeof(hash_table));
668 set_bit_le(255, hash_table); /* Broadcast entry */
669 /* This should work on big-endian machines as well. */
670 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
671 i++, mclist = mclist->next) {
672 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
673
674 set_bit_le(index, hash_table);
675
676 for (i = 0; i < 32; i++) {
677 *setup_frm++ = hash_table[i];
678 *setup_frm++ = hash_table[i];
679 }
680 setup_frm = &de->setup_frame[13*6];
681 }
682
683 /* Fill the final entry with our physical address. */
684 eaddrs = (u16 *)dev->dev_addr;
685 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
686 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
687 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
688 }
689
690 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
691 {
692 struct de_private *de = dev->priv;
693 struct dev_mc_list *mclist;
694 int i;
695 u16 *eaddrs;
696
697 /* We have <= 14 addresses so we can use the wonderful
698 16 address perfect filtering of the Tulip. */
699 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
700 i++, mclist = mclist->next) {
701 eaddrs = (u16 *)mclist->dmi_addr;
702 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
703 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
704 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
705 }
706 /* Fill the unused entries with the broadcast address. */
707 memset(setup_frm, 0xff, (15-i)*12);
708 setup_frm = &de->setup_frame[15*6];
709
710 /* Fill the final entry with our physical address. */
711 eaddrs = (u16 *)dev->dev_addr;
712 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
713 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
714 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
715 }
716
717
718 static void __de_set_rx_mode (struct net_device *dev)
719 {
720 struct de_private *de = dev->priv;
721 u32 macmode;
722 unsigned int entry;
723 u32 mapping;
724 struct de_desc *txd;
725 struct de_desc *dummy_txd = NULL;
726
727 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
728
729 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
730 macmode |= AcceptAllMulticast | AcceptAllPhys;
731 goto out;
732 }
733
734 if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
735 /* Too many to filter well -- accept all multicasts. */
736 macmode |= AcceptAllMulticast;
737 goto out;
738 }
739
740 /* Note that only the low-address shortword of setup_frame is valid!
741 The values are doubled for big-endian architectures. */
742 if (dev->mc_count > 14) /* Must use a multicast hash table. */
743 build_setup_frame_hash (de->setup_frame, dev);
744 else
745 build_setup_frame_perfect (de->setup_frame, dev);
746
747 /*
748 * Now add this frame to the Tx list.
749 */
750
751 entry = de->tx_head;
752
753 /* Avoid a chip errata by prefixing a dummy entry. */
754 if (entry != 0) {
755 de->tx_skb[entry].skb = DE_DUMMY_SKB;
756
757 dummy_txd = &de->tx_ring[entry];
758 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
759 cpu_to_le32(RingEnd) : 0;
760 dummy_txd->addr1 = 0;
761
762 /* Must set DescOwned later to avoid race with chip */
763
764 entry = NEXT_TX(entry);
765 }
766
767 de->tx_skb[entry].skb = DE_SETUP_SKB;
768 de->tx_skb[entry].mapping = mapping =
769 pci_map_single (de->pdev, de->setup_frame,
770 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
771
772 /* Put the setup frame on the Tx list. */
773 txd = &de->tx_ring[entry];
774 if (entry == (DE_TX_RING_SIZE - 1))
775 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
776 else
777 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
778 txd->addr1 = cpu_to_le32(mapping);
779 wmb();
780
781 txd->opts1 = cpu_to_le32(DescOwn);
782 wmb();
783
784 if (dummy_txd) {
785 dummy_txd->opts1 = cpu_to_le32(DescOwn);
786 wmb();
787 }
788
789 de->tx_head = NEXT_TX(entry);
790
791 if (TX_BUFFS_AVAIL(de) < 0)
792 BUG();
793 if (TX_BUFFS_AVAIL(de) == 0)
794 netif_stop_queue(dev);
795
796 /* Trigger an immediate transmit demand. */
797 dw32(TxPoll, NormalTxPoll);
798
799 out:
800 if (macmode != dr32(MacMode))
801 dw32(MacMode, macmode);
802 }
803
804 static void de_set_rx_mode (struct net_device *dev)
805 {
806 unsigned long flags;
807 struct de_private *de = dev->priv;
808
809 spin_lock_irqsave (&de->lock, flags);
810 __de_set_rx_mode(dev);
811 spin_unlock_irqrestore (&de->lock, flags);
812 }
813
814 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
815 {
816 if (unlikely(rx_missed & RxMissedOver))
817 de->net_stats.rx_missed_errors += RxMissedMask;
818 else
819 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
820 }
821
822 static void __de_get_stats(struct de_private *de)
823 {
824 u32 tmp = dr32(RxMissed); /* self-clearing */
825
826 de_rx_missed(de, tmp);
827 }
828
829 static struct net_device_stats *de_get_stats(struct net_device *dev)
830 {
831 struct de_private *de = dev->priv;
832
833 /* The chip only need report frame silently dropped. */
834 spin_lock_irq(&de->lock);
835 if (netif_running(dev) && netif_device_present(dev))
836 __de_get_stats(de);
837 spin_unlock_irq(&de->lock);
838
839 return &de->net_stats;
840 }
841
842 static inline int de_is_running (struct de_private *de)
843 {
844 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
845 }
846
847 static void de_stop_rxtx (struct de_private *de)
848 {
849 u32 macmode;
850 unsigned int work = 1000;
851
852 macmode = dr32(MacMode);
853 if (macmode & RxTx) {
854 dw32(MacMode, macmode & ~RxTx);
855 dr32(MacMode);
856 }
857
858 while (--work > 0) {
859 if (!de_is_running(de))
860 return;
861 cpu_relax();
862 }
863
864 printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
865 }
866
867 static inline void de_start_rxtx (struct de_private *de)
868 {
869 u32 macmode;
870
871 macmode = dr32(MacMode);
872 if ((macmode & RxTx) != RxTx) {
873 dw32(MacMode, macmode | RxTx);
874 dr32(MacMode);
875 }
876 }
877
878 static void de_stop_hw (struct de_private *de)
879 {
880
881 udelay(5);
882 dw32(IntrMask, 0);
883
884 de_stop_rxtx(de);
885
886 dw32(MacStatus, dr32(MacStatus));
887
888 udelay(10);
889
890 de->rx_tail = 0;
891 de->tx_head = de->tx_tail = 0;
892 }
893
894 static void de_link_up(struct de_private *de)
895 {
896 if (!netif_carrier_ok(de->dev)) {
897 netif_carrier_on(de->dev);
898 if (netif_msg_link(de))
899 printk(KERN_INFO "%s: link up, media %s\n",
900 de->dev->name, media_name[de->media_type]);
901 }
902 }
903
904 static void de_link_down(struct de_private *de)
905 {
906 if (netif_carrier_ok(de->dev)) {
907 netif_carrier_off(de->dev);
908 if (netif_msg_link(de))
909 printk(KERN_INFO "%s: link down\n", de->dev->name);
910 }
911 }
912
913 static void de_set_media (struct de_private *de)
914 {
915 unsigned media = de->media_type;
916 u32 macmode = dr32(MacMode);
917
918 if (de_is_running(de))
919 BUG();
920
921 if (de->de21040)
922 dw32(CSR11, FULL_DUPLEX_MAGIC);
923 dw32(CSR13, 0); /* Reset phy */
924 dw32(CSR14, de->media[media].csr14);
925 dw32(CSR15, de->media[media].csr15);
926 dw32(CSR13, de->media[media].csr13);
927
928 /* must delay 10ms before writing to other registers,
929 * especially CSR6
930 */
931 mdelay(10);
932
933 if (media == DE_MEDIA_TP_FD)
934 macmode |= FullDuplex;
935 else
936 macmode &= ~FullDuplex;
937
938 if (netif_msg_link(de)) {
939 printk(KERN_INFO "%s: set link %s\n"
940 KERN_INFO "%s: mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
941 KERN_INFO "%s: set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
942 de->dev->name, media_name[media],
943 de->dev->name, dr32(MacMode), dr32(SIAStatus),
944 dr32(CSR13), dr32(CSR14), dr32(CSR15),
945 de->dev->name, macmode, de->media[media].csr13,
946 de->media[media].csr14, de->media[media].csr15);
947 }
948 if (macmode != dr32(MacMode))
949 dw32(MacMode, macmode);
950 }
951
952 static void de_next_media (struct de_private *de, u32 *media,
953 unsigned int n_media)
954 {
955 unsigned int i;
956
957 for (i = 0; i < n_media; i++) {
958 if (de_ok_to_advertise(de, media[i])) {
959 de->media_type = media[i];
960 return;
961 }
962 }
963 }
964
965 static void de21040_media_timer (unsigned long data)
966 {
967 struct de_private *de = (struct de_private *) data;
968 struct net_device *dev = de->dev;
969 u32 status = dr32(SIAStatus);
970 unsigned int carrier;
971 unsigned long flags;
972
973 carrier = (status & NetCxnErr) ? 0 : 1;
974
975 if (carrier) {
976 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
977 goto no_link_yet;
978
979 de->media_timer.expires = jiffies + DE_TIMER_LINK;
980 add_timer(&de->media_timer);
981 if (!netif_carrier_ok(dev))
982 de_link_up(de);
983 else
984 if (netif_msg_timer(de))
985 printk(KERN_INFO "%s: %s link ok, status %x\n",
986 dev->name, media_name[de->media_type],
987 status);
988 return;
989 }
990
991 de_link_down(de);
992
993 if (de->media_lock)
994 return;
995
996 if (de->media_type == DE_MEDIA_AUI) {
997 u32 next_state = DE_MEDIA_TP;
998 de_next_media(de, &next_state, 1);
999 } else {
1000 u32 next_state = DE_MEDIA_AUI;
1001 de_next_media(de, &next_state, 1);
1002 }
1003
1004 spin_lock_irqsave(&de->lock, flags);
1005 de_stop_rxtx(de);
1006 spin_unlock_irqrestore(&de->lock, flags);
1007 de_set_media(de);
1008 de_start_rxtx(de);
1009
1010 no_link_yet:
1011 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1012 add_timer(&de->media_timer);
1013
1014 if (netif_msg_timer(de))
1015 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1016 dev->name, media_name[de->media_type], status);
1017 }
1018
1019 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1020 {
1021 switch (new_media) {
1022 case DE_MEDIA_TP_AUTO:
1023 if (!(de->media_advertise & ADVERTISED_Autoneg))
1024 return 0;
1025 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1026 return 0;
1027 break;
1028 case DE_MEDIA_BNC:
1029 if (!(de->media_advertise & ADVERTISED_BNC))
1030 return 0;
1031 break;
1032 case DE_MEDIA_AUI:
1033 if (!(de->media_advertise & ADVERTISED_AUI))
1034 return 0;
1035 break;
1036 case DE_MEDIA_TP:
1037 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1038 return 0;
1039 break;
1040 case DE_MEDIA_TP_FD:
1041 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1042 return 0;
1043 break;
1044 }
1045
1046 return 1;
1047 }
1048
1049 static void de21041_media_timer (unsigned long data)
1050 {
1051 struct de_private *de = (struct de_private *) data;
1052 struct net_device *dev = de->dev;
1053 u32 status = dr32(SIAStatus);
1054 unsigned int carrier;
1055 unsigned long flags;
1056
1057 carrier = (status & NetCxnErr) ? 0 : 1;
1058
1059 if (carrier) {
1060 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1061 de->media_type == DE_MEDIA_TP ||
1062 de->media_type == DE_MEDIA_TP_FD) &&
1063 (status & LinkFailStatus))
1064 goto no_link_yet;
1065
1066 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1067 add_timer(&de->media_timer);
1068 if (!netif_carrier_ok(dev))
1069 de_link_up(de);
1070 else
1071 if (netif_msg_timer(de))
1072 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1073 dev->name, media_name[de->media_type],
1074 dr32(MacMode), status);
1075 return;
1076 }
1077
1078 de_link_down(de);
1079
1080 /* if media type locked, don't switch media */
1081 if (de->media_lock)
1082 goto set_media;
1083
1084 /* if activity detected, use that as hint for new media type */
1085 if (status & NonselPortActive) {
1086 unsigned int have_media = 1;
1087
1088 /* if AUI/BNC selected, then activity is on TP port */
1089 if (de->media_type == DE_MEDIA_AUI ||
1090 de->media_type == DE_MEDIA_BNC) {
1091 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1092 de->media_type = DE_MEDIA_TP_AUTO;
1093 else
1094 have_media = 0;
1095 }
1096
1097 /* TP selected. If there is only TP and BNC, then it's BNC */
1098 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1099 de_ok_to_advertise(de, DE_MEDIA_BNC))
1100 de->media_type = DE_MEDIA_BNC;
1101
1102 /* TP selected. If there is only TP and AUI, then it's AUI */
1103 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1104 de_ok_to_advertise(de, DE_MEDIA_AUI))
1105 de->media_type = DE_MEDIA_AUI;
1106
1107 /* otherwise, ignore the hint */
1108 else
1109 have_media = 0;
1110
1111 if (have_media)
1112 goto set_media;
1113 }
1114
1115 /*
1116 * Absent or ambiguous activity hint, move to next advertised
1117 * media state. If de->media_type is left unchanged, this
1118 * simply resets the PHY and reloads the current media settings.
1119 */
1120 if (de->media_type == DE_MEDIA_AUI) {
1121 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1122 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1123 } else if (de->media_type == DE_MEDIA_BNC) {
1124 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1125 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1126 } else {
1127 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1128 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1129 }
1130
1131 set_media:
1132 spin_lock_irqsave(&de->lock, flags);
1133 de_stop_rxtx(de);
1134 spin_unlock_irqrestore(&de->lock, flags);
1135 de_set_media(de);
1136 de_start_rxtx(de);
1137
1138 no_link_yet:
1139 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1140 add_timer(&de->media_timer);
1141
1142 if (netif_msg_timer(de))
1143 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1144 dev->name, media_name[de->media_type], status);
1145 }
1146
1147 static void de_media_interrupt (struct de_private *de, u32 status)
1148 {
1149 if (status & LinkPass) {
1150 de_link_up(de);
1151 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1152 return;
1153 }
1154
1155 if (!(status & LinkFail))
1156 BUG();
1157
1158 if (netif_carrier_ok(de->dev)) {
1159 de_link_down(de);
1160 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1161 }
1162 }
1163
1164 static int de_reset_mac (struct de_private *de)
1165 {
1166 u32 status, tmp;
1167
1168 /*
1169 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1170 * in this area.
1171 */
1172
1173 if (dr32(BusMode) == 0xffffffff)
1174 return -EBUSY;
1175
1176 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1177 dw32 (BusMode, CmdReset);
1178 mdelay (1);
1179
1180 dw32 (BusMode, de_bus_mode);
1181 mdelay (1);
1182
1183 for (tmp = 0; tmp < 5; tmp++) {
1184 dr32 (BusMode);
1185 mdelay (1);
1186 }
1187
1188 mdelay (1);
1189
1190 status = dr32(MacStatus);
1191 if (status & (RxState | TxState))
1192 return -EBUSY;
1193 if (status == 0xffffffff)
1194 return -ENODEV;
1195 return 0;
1196 }
1197
1198 static void de_adapter_wake (struct de_private *de)
1199 {
1200 u32 pmctl;
1201
1202 if (de->de21040)
1203 return;
1204
1205 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1206 if (pmctl & PM_Mask) {
1207 pmctl &= ~PM_Mask;
1208 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1209
1210 /* de4x5.c delays, so we do too */
1211 current->state = TASK_UNINTERRUPTIBLE;
1212 schedule_timeout(msecs_to_jiffies(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 if (boguscnt <= 0)
1707 printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
1708 }
1709 }
1710
1711 static void __init de21040_get_media_info(struct de_private *de)
1712 {
1713 unsigned int i;
1714
1715 de->media_type = DE_MEDIA_TP;
1716 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1717 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1718 de->media_advertise = de->media_supported;
1719
1720 for (i = 0; i < DE_MAX_MEDIA; i++) {
1721 switch (i) {
1722 case DE_MEDIA_AUI:
1723 case DE_MEDIA_TP:
1724 case DE_MEDIA_TP_FD:
1725 de->media[i].type = i;
1726 de->media[i].csr13 = t21040_csr13[i];
1727 de->media[i].csr14 = t21040_csr14[i];
1728 de->media[i].csr15 = t21040_csr15[i];
1729 break;
1730 default:
1731 de->media[i].type = DE_MEDIA_INVALID;
1732 break;
1733 }
1734 }
1735 }
1736
1737 /* Note: this routine returns extra data bits for size detection. */
1738 static unsigned __init tulip_read_eeprom(void *regs, int location, int addr_len)
1739 {
1740 int i;
1741 unsigned retval = 0;
1742 void *ee_addr = regs + ROMCmd;
1743 int read_cmd = location | (EE_READ_CMD << addr_len);
1744
1745 writel(EE_ENB & ~EE_CS, ee_addr);
1746 writel(EE_ENB, ee_addr);
1747
1748 /* Shift the read command bits out. */
1749 for (i = 4 + addr_len; i >= 0; i--) {
1750 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1751 writel(EE_ENB | dataval, ee_addr);
1752 readl(ee_addr);
1753 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1754 readl(ee_addr);
1755 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1756 }
1757 writel(EE_ENB, ee_addr);
1758 readl(ee_addr);
1759
1760 for (i = 16; i > 0; i--) {
1761 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1762 readl(ee_addr);
1763 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1764 writel(EE_ENB, ee_addr);
1765 readl(ee_addr);
1766 }
1767
1768 /* Terminate the EEPROM access. */
1769 writel(EE_ENB & ~EE_CS, ee_addr);
1770 return retval;
1771 }
1772
1773 static void __init de21041_get_srom_info (struct de_private *de)
1774 {
1775 unsigned i, sa_offset = 0, ofs;
1776 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1777 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1778 struct de_srom_info_leaf *il;
1779 void *bufp;
1780
1781 /* download entire eeprom */
1782 for (i = 0; i < DE_EEPROM_WORDS; i++)
1783 ((u16 *)ee_data)[i] =
1784 le16_to_cpu(tulip_read_eeprom(de->regs, i, ee_addr_size));
1785
1786 /* DEC now has a specification but early board makers
1787 just put the address in the first EEPROM locations. */
1788 /* This does memcmp(eedata, eedata+16, 8) */
1789 for (i = 0; i < 8; i ++)
1790 if (ee_data[i] != ee_data[16+i])
1791 sa_offset = 20;
1792
1793 /* store MAC address */
1794 for (i = 0; i < 6; i ++)
1795 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1796
1797 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1798 ofs = ee_data[SROMC0InfoLeaf];
1799 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1800 goto bad_srom;
1801
1802 /* get pointer to info leaf */
1803 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1804
1805 /* paranoia checks */
1806 if (il->n_blocks == 0)
1807 goto bad_srom;
1808 if ((sizeof(ee_data) - ofs) <
1809 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1810 goto bad_srom;
1811
1812 /* get default media type */
1813 switch (DE_UNALIGNED_16(&il->default_media)) {
1814 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1815 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1816 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1817 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1818 }
1819
1820 if (netif_msg_probe(de))
1821 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1822 de->board_idx, ofs,
1823 media_name[de->media_type]);
1824
1825 /* init SIA register values to defaults */
1826 for (i = 0; i < DE_MAX_MEDIA; i++) {
1827 de->media[i].type = DE_MEDIA_INVALID;
1828 de->media[i].csr13 = 0xffff;
1829 de->media[i].csr14 = 0xffff;
1830 de->media[i].csr15 = 0xffff;
1831 }
1832
1833 /* parse media blocks to see what medias are supported,
1834 * and if any custom CSR values are provided
1835 */
1836 bufp = ((void *)il) + sizeof(*il);
1837 for (i = 0; i < il->n_blocks; i++) {
1838 struct de_srom_media_block *ib = bufp;
1839 unsigned idx;
1840
1841 /* index based on media type in media block */
1842 switch(ib->opts & MediaBlockMask) {
1843 case 0: /* 10baseT */
1844 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1845 | SUPPORTED_Autoneg;
1846 idx = DE_MEDIA_TP;
1847 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1848 break;
1849 case 1: /* BNC */
1850 de->media_supported |= SUPPORTED_BNC;
1851 idx = DE_MEDIA_BNC;
1852 break;
1853 case 2: /* AUI */
1854 de->media_supported |= SUPPORTED_AUI;
1855 idx = DE_MEDIA_AUI;
1856 break;
1857 case 4: /* 10baseT-FD */
1858 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1859 | SUPPORTED_Autoneg;
1860 idx = DE_MEDIA_TP_FD;
1861 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1862 break;
1863 default:
1864 goto bad_srom;
1865 }
1866
1867 de->media[idx].type = idx;
1868
1869 if (netif_msg_probe(de))
1870 printk(KERN_INFO "de%d: media block #%u: %s",
1871 de->board_idx, i,
1872 media_name[de->media[idx].type]);
1873
1874 bufp += sizeof (ib->opts);
1875
1876 if (ib->opts & MediaCustomCSRs) {
1877 de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
1878 de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1879 de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
1880 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1881 sizeof(ib->csr15);
1882
1883 if (netif_msg_probe(de))
1884 printk(" (%x,%x,%x)\n",
1885 de->media[idx].csr13,
1886 de->media[idx].csr14,
1887 de->media[idx].csr15);
1888
1889 } else if (netif_msg_probe(de))
1890 printk("\n");
1891
1892 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1893 break;
1894 }
1895
1896 de->media_advertise = de->media_supported;
1897
1898 fill_defaults:
1899 /* fill in defaults, for cases where custom CSRs not used */
1900 for (i = 0; i < DE_MAX_MEDIA; i++) {
1901 if (de->media[i].csr13 == 0xffff)
1902 de->media[i].csr13 = t21041_csr13[i];
1903 if (de->media[i].csr14 == 0xffff)
1904 de->media[i].csr14 = t21041_csr14[i];
1905 if (de->media[i].csr15 == 0xffff)
1906 de->media[i].csr15 = t21041_csr15[i];
1907 }
1908
1909 de->ee_data = kmalloc(DE_EEPROM_SIZE, GFP_KERNEL);
1910 if (de->ee_data)
1911 memcpy(de->ee_data, &ee_data[0], DE_EEPROM_SIZE);
1912
1913 return;
1914
1915 bad_srom:
1916 /* for error cases, it's ok to assume we support all these */
1917 for (i = 0; i < DE_MAX_MEDIA; i++)
1918 de->media[i].type = i;
1919 de->media_supported =
1920 SUPPORTED_10baseT_Half |
1921 SUPPORTED_10baseT_Full |
1922 SUPPORTED_Autoneg |
1923 SUPPORTED_TP |
1924 SUPPORTED_AUI |
1925 SUPPORTED_BNC;
1926 goto fill_defaults;
1927 }
1928
1929 static int __devinit de_init_one (struct pci_dev *pdev,
1930 const struct pci_device_id *ent)
1931 {
1932 struct net_device *dev;
1933 struct de_private *de;
1934 int rc;
1935 void *regs;
1936 long pciaddr;
1937 static int board_idx = -1;
1938
1939 board_idx++;
1940
1941 #ifndef MODULE
1942 if (board_idx == 0)
1943 printk("%s", version);
1944 #endif
1945
1946 /* allocate a new ethernet device structure, and fill in defaults */
1947 dev = alloc_etherdev(sizeof(struct de_private));
1948 if (!dev)
1949 return -ENOMEM;
1950
1951 SET_MODULE_OWNER(dev);
1952 SET_NETDEV_DEV(dev, &pdev->dev);
1953 dev->open = de_open;
1954 dev->stop = de_close;
1955 dev->set_multicast_list = de_set_rx_mode;
1956 dev->hard_start_xmit = de_start_xmit;
1957 dev->get_stats = de_get_stats;
1958 dev->ethtool_ops = &de_ethtool_ops;
1959 dev->tx_timeout = de_tx_timeout;
1960 dev->watchdog_timeo = TX_TIMEOUT;
1961
1962 dev->irq = pdev->irq;
1963
1964 de = dev->priv;
1965 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1966 de->pdev = pdev;
1967 de->dev = dev;
1968 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1969 de->board_idx = board_idx;
1970 spin_lock_init (&de->lock);
1971 init_timer(&de->media_timer);
1972 if (de->de21040)
1973 de->media_timer.function = de21040_media_timer;
1974 else
1975 de->media_timer.function = de21041_media_timer;
1976 de->media_timer.data = (unsigned long) de;
1977
1978 netif_carrier_off(dev);
1979 netif_stop_queue(dev);
1980
1981 /* wake up device, assign resources */
1982 rc = pci_enable_device(pdev);
1983 if (rc)
1984 goto err_out_free;
1985
1986 /* reserve PCI resources to ensure driver atomicity */
1987 rc = pci_request_regions(pdev, DRV_NAME);
1988 if (rc)
1989 goto err_out_disable;
1990
1991 /* check for invalid IRQ value */
1992 if (pdev->irq < 2) {
1993 rc = -EIO;
1994 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
1995 pdev->irq, pci_name(pdev));
1996 goto err_out_res;
1997 }
1998
1999 /* obtain and check validity of PCI I/O address */
2000 pciaddr = pci_resource_start(pdev, 1);
2001 if (!pciaddr) {
2002 rc = -EIO;
2003 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
2004 pci_name(pdev));
2005 goto err_out_res;
2006 }
2007 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2008 rc = -EIO;
2009 printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
2010 pci_resource_len(pdev, 1), pci_name(pdev));
2011 goto err_out_res;
2012 }
2013
2014 /* remap CSR registers */
2015 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2016 if (!regs) {
2017 rc = -EIO;
2018 printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
2019 pci_resource_len(pdev, 1), pciaddr, pci_name(pdev));
2020 goto err_out_res;
2021 }
2022 dev->base_addr = (unsigned long) regs;
2023 de->regs = regs;
2024
2025 de_adapter_wake(de);
2026
2027 /* make sure hardware is not running */
2028 rc = de_reset_mac(de);
2029 if (rc) {
2030 printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
2031 pci_name(pdev));
2032 goto err_out_iomap;
2033 }
2034
2035 /* get MAC address, initialize default media type and
2036 * get list of supported media
2037 */
2038 if (de->de21040) {
2039 de21040_get_mac_address(de);
2040 de21040_get_media_info(de);
2041 } else {
2042 de21041_get_srom_info(de);
2043 }
2044
2045 /* register new network interface with kernel */
2046 rc = register_netdev(dev);
2047 if (rc)
2048 goto err_out_iomap;
2049
2050 /* print info about board and interface just registered */
2051 printk (KERN_INFO "%s: %s at 0x%lx, "
2052 "%02x:%02x:%02x:%02x:%02x:%02x, "
2053 "IRQ %d\n",
2054 dev->name,
2055 de->de21040 ? "21040" : "21041",
2056 dev->base_addr,
2057 dev->dev_addr[0], dev->dev_addr[1],
2058 dev->dev_addr[2], dev->dev_addr[3],
2059 dev->dev_addr[4], dev->dev_addr[5],
2060 dev->irq);
2061
2062 pci_set_drvdata(pdev, dev);
2063
2064 /* enable busmastering */
2065 pci_set_master(pdev);
2066
2067 /* put adapter to sleep */
2068 de_adapter_sleep(de);
2069
2070 return 0;
2071
2072 err_out_iomap:
2073 if (de->ee_data)
2074 kfree(de->ee_data);
2075 iounmap(regs);
2076 err_out_res:
2077 pci_release_regions(pdev);
2078 err_out_disable:
2079 pci_disable_device(pdev);
2080 err_out_free:
2081 free_netdev(dev);
2082 return rc;
2083 }
2084
2085 static void __exit de_remove_one (struct pci_dev *pdev)
2086 {
2087 struct net_device *dev = pci_get_drvdata(pdev);
2088 struct de_private *de = dev->priv;
2089
2090 if (!dev)
2091 BUG();
2092 unregister_netdev(dev);
2093 if (de->ee_data)
2094 kfree(de->ee_data);
2095 iounmap(de->regs);
2096 pci_release_regions(pdev);
2097 pci_disable_device(pdev);
2098 pci_set_drvdata(pdev, NULL);
2099 free_netdev(dev);
2100 }
2101
2102 #ifdef CONFIG_PM
2103
2104 static int de_suspend (struct pci_dev *pdev, u32 state)
2105 {
2106 struct net_device *dev = pci_get_drvdata (pdev);
2107 struct de_private *de = dev->priv;
2108
2109 rtnl_lock();
2110 if (netif_running (dev)) {
2111 del_timer_sync(&de->media_timer);
2112
2113 disable_irq(dev->irq);
2114 spin_lock_irq(&de->lock);
2115
2116 de_stop_hw(de);
2117 netif_stop_queue(dev);
2118 netif_device_detach(dev);
2119 netif_carrier_off(dev);
2120
2121 spin_unlock_irq(&de->lock);
2122 enable_irq(dev->irq);
2123
2124 /* Update the error counts. */
2125 __de_get_stats(de);
2126
2127 synchronize_irq(dev->irq);
2128 de_clean_rings(de);
2129
2130 de_adapter_sleep(de);
2131 pci_disable_device(pdev);
2132 } else {
2133 netif_device_detach(dev);
2134 }
2135 rtnl_unlock();
2136 return 0;
2137 }
2138
2139 static int de_resume (struct pci_dev *pdev)
2140 {
2141 struct net_device *dev = pci_get_drvdata (pdev);
2142 struct de_private *de = dev->priv;
2143
2144 rtnl_lock();
2145 if (netif_device_present(dev))
2146 goto out;
2147 if (netif_running(dev)) {
2148 pci_enable_device(pdev);
2149 de_init_hw(de);
2150 netif_device_attach(dev);
2151 } else {
2152 netif_device_attach(dev);
2153 }
2154 out:
2155 rtnl_unlock();
2156 return 0;
2157 }
2158
2159 #endif /* CONFIG_PM */
2160
2161 static struct pci_driver de_driver = {
2162 .name = DRV_NAME,
2163 .id_table = de_pci_tbl,
2164 .probe = de_init_one,
2165 .remove = __exit_p(de_remove_one),
2166 #ifdef CONFIG_PM
2167 .suspend = de_suspend,
2168 .resume = de_resume,
2169 #endif
2170 };
2171
2172 static int __init de_init (void)
2173 {
2174 #ifdef MODULE
2175 printk("%s", version);
2176 #endif
2177 return pci_module_init (&de_driver);
2178 }
2179
2180 static void __exit de_exit (void)
2181 {
2182 pci_unregister_driver (&de_driver);
2183 }
2184
2185 module_init(de_init);
2186 module_exit(de_exit);
MOXA 2.6.9 from sdlinux-moxaart.tgz