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