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