?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Audit: move audit_get_nd completely into audit_watch
[linux-2.6/mini2440.git] / drivers / net / tulip / de2104x.c
blob81f054dbb88ddb2712bc6d60921f857c3920a05e
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 struct pci_device_id 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 int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
603 {
604 struct de_private *de = netdev_priv(dev);
605 unsigned int entry, tx_free;
606 u32 mapping, len, flags = FirstFrag | LastFrag;
607 struct de_desc *txd;
608
609 spin_lock_irq(&de->lock);
610
611 tx_free = TX_BUFFS_AVAIL(de);
612 if (tx_free == 0) {
613 netif_stop_queue(dev);
614 spin_unlock_irq(&de->lock);
615 return NETDEV_TX_BUSY;
616 }
617 tx_free--;
618
619 entry = de->tx_head;
620
621 txd = &de->tx_ring[entry];
622
623 len = skb->len;
624 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
625 if (entry == (DE_TX_RING_SIZE - 1))
626 flags |= RingEnd;
627 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
628 flags |= TxSwInt;
629 flags |= len;
630 txd->opts2 = cpu_to_le32(flags);
631 txd->addr1 = cpu_to_le32(mapping);
632
633 de->tx_skb[entry].skb = skb;
634 de->tx_skb[entry].mapping = mapping;
635 wmb();
636
637 txd->opts1 = cpu_to_le32(DescOwn);
638 wmb();
639
640 de->tx_head = NEXT_TX(entry);
641 if (netif_msg_tx_queued(de))
642 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
643 dev->name, entry, skb->len);
644
645 if (tx_free == 0)
646 netif_stop_queue(dev);
647
648 spin_unlock_irq(&de->lock);
649
650 /* Trigger an immediate transmit demand. */
651 dw32(TxPoll, NormalTxPoll);
652 dev->trans_start = jiffies;
653
654 return 0;
655 }
656
657 /* Set or clear the multicast filter for this adaptor.
658 Note that we only use exclusion around actually queueing the
659 new frame, not around filling de->setup_frame. This is non-deterministic
660 when re-entered but still correct. */
661
662 #undef set_bit_le
663 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
664
665 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
666 {
667 struct de_private *de = netdev_priv(dev);
668 u16 hash_table[32];
669 struct dev_mc_list *mclist;
670 int i;
671 u16 *eaddrs;
672
673 memset(hash_table, 0, sizeof(hash_table));
674 set_bit_le(255, hash_table); /* Broadcast entry */
675 /* This should work on big-endian machines as well. */
676 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
677 i++, mclist = mclist->next) {
678 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
679
680 set_bit_le(index, hash_table);
681
682 for (i = 0; i < 32; i++) {
683 *setup_frm++ = hash_table[i];
684 *setup_frm++ = hash_table[i];
685 }
686 setup_frm = &de->setup_frame[13*6];
687 }
688
689 /* Fill the final entry with our physical address. */
690 eaddrs = (u16 *)dev->dev_addr;
691 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
692 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
693 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
694 }
695
696 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
697 {
698 struct de_private *de = netdev_priv(dev);
699 struct dev_mc_list *mclist;
700 int i;
701 u16 *eaddrs;
702
703 /* We have <= 14 addresses so we can use the wonderful
704 16 address perfect filtering of the Tulip. */
705 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
706 i++, mclist = mclist->next) {
707 eaddrs = (u16 *)mclist->dmi_addr;
708 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
709 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
710 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
711 }
712 /* Fill the unused entries with the broadcast address. */
713 memset(setup_frm, 0xff, (15-i)*12);
714 setup_frm = &de->setup_frame[15*6];
715
716 /* Fill the final entry with our physical address. */
717 eaddrs = (u16 *)dev->dev_addr;
718 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
719 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
720 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
721 }
722
723
724 static void __de_set_rx_mode (struct net_device *dev)
725 {
726 struct de_private *de = netdev_priv(dev);
727 u32 macmode;
728 unsigned int entry;
729 u32 mapping;
730 struct de_desc *txd;
731 struct de_desc *dummy_txd = NULL;
732
733 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
734
735 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
736 macmode |= AcceptAllMulticast | AcceptAllPhys;
737 goto out;
738 }
739
740 if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
741 /* Too many to filter well -- accept all multicasts. */
742 macmode |= AcceptAllMulticast;
743 goto out;
744 }
745
746 /* Note that only the low-address shortword of setup_frame is valid!
747 The values are doubled for big-endian architectures. */
748 if (dev->mc_count > 14) /* Must use a multicast hash table. */
749 build_setup_frame_hash (de->setup_frame, dev);
750 else
751 build_setup_frame_perfect (de->setup_frame, dev);
752
753 /*
754 * Now add this frame to the Tx list.
755 */
756
757 entry = de->tx_head;
758
759 /* Avoid a chip errata by prefixing a dummy entry. */
760 if (entry != 0) {
761 de->tx_skb[entry].skb = DE_DUMMY_SKB;
762
763 dummy_txd = &de->tx_ring[entry];
764 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
765 cpu_to_le32(RingEnd) : 0;
766 dummy_txd->addr1 = 0;
767
768 /* Must set DescOwned later to avoid race with chip */
769
770 entry = NEXT_TX(entry);
771 }
772
773 de->tx_skb[entry].skb = DE_SETUP_SKB;
774 de->tx_skb[entry].mapping = mapping =
775 pci_map_single (de->pdev, de->setup_frame,
776 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
777
778 /* Put the setup frame on the Tx list. */
779 txd = &de->tx_ring[entry];
780 if (entry == (DE_TX_RING_SIZE - 1))
781 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
782 else
783 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
784 txd->addr1 = cpu_to_le32(mapping);
785 wmb();
786
787 txd->opts1 = cpu_to_le32(DescOwn);
788 wmb();
789
790 if (dummy_txd) {
791 dummy_txd->opts1 = cpu_to_le32(DescOwn);
792 wmb();
793 }
794
795 de->tx_head = NEXT_TX(entry);
796
797 if (TX_BUFFS_AVAIL(de) == 0)
798 netif_stop_queue(dev);
799
800 /* Trigger an immediate transmit demand. */
801 dw32(TxPoll, NormalTxPoll);
802
803 out:
804 if (macmode != dr32(MacMode))
805 dw32(MacMode, macmode);
806 }
807
808 static void de_set_rx_mode (struct net_device *dev)
809 {
810 unsigned long flags;
811 struct de_private *de = netdev_priv(dev);
812
813 spin_lock_irqsave (&de->lock, flags);
814 __de_set_rx_mode(dev);
815 spin_unlock_irqrestore (&de->lock, flags);
816 }
817
818 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
819 {
820 if (unlikely(rx_missed & RxMissedOver))
821 de->net_stats.rx_missed_errors += RxMissedMask;
822 else
823 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
824 }
825
826 static void __de_get_stats(struct de_private *de)
827 {
828 u32 tmp = dr32(RxMissed); /* self-clearing */
829
830 de_rx_missed(de, tmp);
831 }
832
833 static struct net_device_stats *de_get_stats(struct net_device *dev)
834 {
835 struct de_private *de = netdev_priv(dev);
836
837 /* The chip only need report frame silently dropped. */
838 spin_lock_irq(&de->lock);
839 if (netif_running(dev) && netif_device_present(dev))
840 __de_get_stats(de);
841 spin_unlock_irq(&de->lock);
842
843 return &de->net_stats;
844 }
845
846 static inline int de_is_running (struct de_private *de)
847 {
848 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
849 }
850
851 static void de_stop_rxtx (struct de_private *de)
852 {
853 u32 macmode;
854 unsigned int i = 1300/100;
855
856 macmode = dr32(MacMode);
857 if (macmode & RxTx) {
858 dw32(MacMode, macmode & ~RxTx);
859 dr32(MacMode);
860 }
861
862 /* wait until in-flight frame completes.
863 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
864 * Typically expect this loop to end in < 50 us on 100BT.
865 */
866 while (--i) {
867 if (!de_is_running(de))
868 return;
869 udelay(100);
870 }
871
872 printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
873 }
874
875 static inline void de_start_rxtx (struct de_private *de)
876 {
877 u32 macmode;
878
879 macmode = dr32(MacMode);
880 if ((macmode & RxTx) != RxTx) {
881 dw32(MacMode, macmode | RxTx);
882 dr32(MacMode);
883 }
884 }
885
886 static void de_stop_hw (struct de_private *de)
887 {
888
889 udelay(5);
890 dw32(IntrMask, 0);
891
892 de_stop_rxtx(de);
893
894 dw32(MacStatus, dr32(MacStatus));
895
896 udelay(10);
897
898 de->rx_tail = 0;
899 de->tx_head = de->tx_tail = 0;
900 }
901
902 static void de_link_up(struct de_private *de)
903 {
904 if (!netif_carrier_ok(de->dev)) {
905 netif_carrier_on(de->dev);
906 if (netif_msg_link(de))
907 printk(KERN_INFO "%s: link up, media %s\n",
908 de->dev->name, media_name[de->media_type]);
909 }
910 }
911
912 static void de_link_down(struct de_private *de)
913 {
914 if (netif_carrier_ok(de->dev)) {
915 netif_carrier_off(de->dev);
916 if (netif_msg_link(de))
917 printk(KERN_INFO "%s: link down\n", de->dev->name);
918 }
919 }
920
921 static void de_set_media (struct de_private *de)
922 {
923 unsigned media = de->media_type;
924 u32 macmode = dr32(MacMode);
925
926 if (de_is_running(de))
927 printk(KERN_WARNING "%s: chip is running while changing media!\n", de->dev->name);
928
929 if (de->de21040)
930 dw32(CSR11, FULL_DUPLEX_MAGIC);
931 dw32(CSR13, 0); /* Reset phy */
932 dw32(CSR14, de->media[media].csr14);
933 dw32(CSR15, de->media[media].csr15);
934 dw32(CSR13, de->media[media].csr13);
935
936 /* must delay 10ms before writing to other registers,
937 * especially CSR6
938 */
939 mdelay(10);
940
941 if (media == DE_MEDIA_TP_FD)
942 macmode |= FullDuplex;
943 else
944 macmode &= ~FullDuplex;
945
946 if (netif_msg_link(de)) {
947 printk(KERN_INFO "%s: set link %s\n"
948 KERN_INFO "%s: mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
949 KERN_INFO "%s: set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
950 de->dev->name, media_name[media],
951 de->dev->name, dr32(MacMode), dr32(SIAStatus),
952 dr32(CSR13), dr32(CSR14), dr32(CSR15),
953 de->dev->name, macmode, de->media[media].csr13,
954 de->media[media].csr14, de->media[media].csr15);
955 }
956 if (macmode != dr32(MacMode))
957 dw32(MacMode, macmode);
958 }
959
960 static void de_next_media (struct de_private *de, u32 *media,
961 unsigned int n_media)
962 {
963 unsigned int i;
964
965 for (i = 0; i < n_media; i++) {
966 if (de_ok_to_advertise(de, media[i])) {
967 de->media_type = media[i];
968 return;
969 }
970 }
971 }
972
973 static void de21040_media_timer (unsigned long data)
974 {
975 struct de_private *de = (struct de_private *) data;
976 struct net_device *dev = de->dev;
977 u32 status = dr32(SIAStatus);
978 unsigned int carrier;
979 unsigned long flags;
980
981 carrier = (status & NetCxnErr) ? 0 : 1;
982
983 if (carrier) {
984 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
985 goto no_link_yet;
986
987 de->media_timer.expires = jiffies + DE_TIMER_LINK;
988 add_timer(&de->media_timer);
989 if (!netif_carrier_ok(dev))
990 de_link_up(de);
991 else
992 if (netif_msg_timer(de))
993 printk(KERN_INFO "%s: %s link ok, status %x\n",
994 dev->name, media_name[de->media_type],
995 status);
996 return;
997 }
998
999 de_link_down(de);
1000
1001 if (de->media_lock)
1002 return;
1003
1004 if (de->media_type == DE_MEDIA_AUI) {
1005 u32 next_state = DE_MEDIA_TP;
1006 de_next_media(de, &next_state, 1);
1007 } else {
1008 u32 next_state = DE_MEDIA_AUI;
1009 de_next_media(de, &next_state, 1);
1010 }
1011
1012 spin_lock_irqsave(&de->lock, flags);
1013 de_stop_rxtx(de);
1014 spin_unlock_irqrestore(&de->lock, flags);
1015 de_set_media(de);
1016 de_start_rxtx(de);
1017
1018 no_link_yet:
1019 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1020 add_timer(&de->media_timer);
1021
1022 if (netif_msg_timer(de))
1023 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1024 dev->name, media_name[de->media_type], status);
1025 }
1026
1027 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1028 {
1029 switch (new_media) {
1030 case DE_MEDIA_TP_AUTO:
1031 if (!(de->media_advertise & ADVERTISED_Autoneg))
1032 return 0;
1033 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1034 return 0;
1035 break;
1036 case DE_MEDIA_BNC:
1037 if (!(de->media_advertise & ADVERTISED_BNC))
1038 return 0;
1039 break;
1040 case DE_MEDIA_AUI:
1041 if (!(de->media_advertise & ADVERTISED_AUI))
1042 return 0;
1043 break;
1044 case DE_MEDIA_TP:
1045 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1046 return 0;
1047 break;
1048 case DE_MEDIA_TP_FD:
1049 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1050 return 0;
1051 break;
1052 }
1053
1054 return 1;
1055 }
1056
1057 static void de21041_media_timer (unsigned long data)
1058 {
1059 struct de_private *de = (struct de_private *) data;
1060 struct net_device *dev = de->dev;
1061 u32 status = dr32(SIAStatus);
1062 unsigned int carrier;
1063 unsigned long flags;
1064
1065 carrier = (status & NetCxnErr) ? 0 : 1;
1066
1067 if (carrier) {
1068 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1069 de->media_type == DE_MEDIA_TP ||
1070 de->media_type == DE_MEDIA_TP_FD) &&
1071 (status & LinkFailStatus))
1072 goto no_link_yet;
1073
1074 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1075 add_timer(&de->media_timer);
1076 if (!netif_carrier_ok(dev))
1077 de_link_up(de);
1078 else
1079 if (netif_msg_timer(de))
1080 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1081 dev->name, media_name[de->media_type],
1082 dr32(MacMode), status);
1083 return;
1084 }
1085
1086 de_link_down(de);
1087
1088 /* if media type locked, don't switch media */
1089 if (de->media_lock)
1090 goto set_media;
1091
1092 /* if activity detected, use that as hint for new media type */
1093 if (status & NonselPortActive) {
1094 unsigned int have_media = 1;
1095
1096 /* if AUI/BNC selected, then activity is on TP port */
1097 if (de->media_type == DE_MEDIA_AUI ||
1098 de->media_type == DE_MEDIA_BNC) {
1099 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1100 de->media_type = DE_MEDIA_TP_AUTO;
1101 else
1102 have_media = 0;
1103 }
1104
1105 /* TP selected. If there is only TP and BNC, then it's BNC */
1106 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1107 de_ok_to_advertise(de, DE_MEDIA_BNC))
1108 de->media_type = DE_MEDIA_BNC;
1109
1110 /* TP selected. If there is only TP and AUI, then it's AUI */
1111 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1112 de_ok_to_advertise(de, DE_MEDIA_AUI))
1113 de->media_type = DE_MEDIA_AUI;
1114
1115 /* otherwise, ignore the hint */
1116 else
1117 have_media = 0;
1118
1119 if (have_media)
1120 goto set_media;
1121 }
1122
1123 /*
1124 * Absent or ambiguous activity hint, move to next advertised
1125 * media state. If de->media_type is left unchanged, this
1126 * simply resets the PHY and reloads the current media settings.
1127 */
1128 if (de->media_type == DE_MEDIA_AUI) {
1129 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1130 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1131 } else if (de->media_type == DE_MEDIA_BNC) {
1132 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1133 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1134 } else {
1135 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1136 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1137 }
1138
1139 set_media:
1140 spin_lock_irqsave(&de->lock, flags);
1141 de_stop_rxtx(de);
1142 spin_unlock_irqrestore(&de->lock, flags);
1143 de_set_media(de);
1144 de_start_rxtx(de);
1145
1146 no_link_yet:
1147 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1148 add_timer(&de->media_timer);
1149
1150 if (netif_msg_timer(de))
1151 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1152 dev->name, media_name[de->media_type], status);
1153 }
1154
1155 static void de_media_interrupt (struct de_private *de, u32 status)
1156 {
1157 if (status & LinkPass) {
1158 de_link_up(de);
1159 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1160 return;
1161 }
1162
1163 BUG_ON(!(status & LinkFail));
1164
1165 if (netif_carrier_ok(de->dev)) {
1166 de_link_down(de);
1167 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1168 }
1169 }
1170
1171 static int de_reset_mac (struct de_private *de)
1172 {
1173 u32 status, tmp;
1174
1175 /*
1176 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1177 * in this area.
1178 */
1179
1180 if (dr32(BusMode) == 0xffffffff)
1181 return -EBUSY;
1182
1183 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1184 dw32 (BusMode, CmdReset);
1185 mdelay (1);
1186
1187 dw32 (BusMode, de_bus_mode);
1188 mdelay (1);
1189
1190 for (tmp = 0; tmp < 5; tmp++) {
1191 dr32 (BusMode);
1192 mdelay (1);
1193 }
1194
1195 mdelay (1);
1196
1197 status = dr32(MacStatus);
1198 if (status & (RxState | TxState))
1199 return -EBUSY;
1200 if (status == 0xffffffff)
1201 return -ENODEV;
1202 return 0;
1203 }
1204
1205 static void de_adapter_wake (struct de_private *de)
1206 {
1207 u32 pmctl;
1208
1209 if (de->de21040)
1210 return;
1211
1212 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1213 if (pmctl & PM_Mask) {
1214 pmctl &= ~PM_Mask;
1215 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1216
1217 /* de4x5.c delays, so we do too */
1218 msleep(10);
1219 }
1220 }
1221
1222 static void de_adapter_sleep (struct de_private *de)
1223 {
1224 u32 pmctl;
1225
1226 if (de->de21040)
1227 return;
1228
1229 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1230 pmctl |= PM_Sleep;
1231 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1232 }
1233
1234 static int de_init_hw (struct de_private *de)
1235 {
1236 struct net_device *dev = de->dev;
1237 u32 macmode;
1238 int rc;
1239
1240 de_adapter_wake(de);
1241
1242 macmode = dr32(MacMode) & ~MacModeClear;
1243
1244 rc = de_reset_mac(de);
1245 if (rc)
1246 return rc;
1247
1248 de_set_media(de); /* reset phy */
1249
1250 dw32(RxRingAddr, de->ring_dma);
1251 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1252
1253 dw32(MacMode, RxTx | macmode);
1254
1255 dr32(RxMissed); /* self-clearing */
1256
1257 dw32(IntrMask, de_intr_mask);
1258
1259 de_set_rx_mode(dev);
1260
1261 return 0;
1262 }
1263
1264 static int de_refill_rx (struct de_private *de)
1265 {
1266 unsigned i;
1267
1268 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1269 struct sk_buff *skb;
1270
1271 skb = dev_alloc_skb(de->rx_buf_sz);
1272 if (!skb)
1273 goto err_out;
1274
1275 skb->dev = de->dev;
1276
1277 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1278 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1279 de->rx_skb[i].skb = skb;
1280
1281 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1282 if (i == (DE_RX_RING_SIZE - 1))
1283 de->rx_ring[i].opts2 =
1284 cpu_to_le32(RingEnd | de->rx_buf_sz);
1285 else
1286 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1287 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1288 de->rx_ring[i].addr2 = 0;
1289 }
1290
1291 return 0;
1292
1293 err_out:
1294 de_clean_rings(de);
1295 return -ENOMEM;
1296 }
1297
1298 static int de_init_rings (struct de_private *de)
1299 {
1300 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1301 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1302
1303 de->rx_tail = 0;
1304 de->tx_head = de->tx_tail = 0;
1305
1306 return de_refill_rx (de);
1307 }
1308
1309 static int de_alloc_rings (struct de_private *de)
1310 {
1311 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1312 if (!de->rx_ring)
1313 return -ENOMEM;
1314 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1315 return de_init_rings(de);
1316 }
1317
1318 static void de_clean_rings (struct de_private *de)
1319 {
1320 unsigned i;
1321
1322 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1323 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1324 wmb();
1325 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1326 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1327 wmb();
1328
1329 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1330 if (de->rx_skb[i].skb) {
1331 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1332 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1333 dev_kfree_skb(de->rx_skb[i].skb);
1334 }
1335 }
1336
1337 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1338 struct sk_buff *skb = de->tx_skb[i].skb;
1339 if ((skb) && (skb != DE_DUMMY_SKB)) {
1340 if (skb != DE_SETUP_SKB) {
1341 de->net_stats.tx_dropped++;
1342 pci_unmap_single(de->pdev,
1343 de->tx_skb[i].mapping,
1344 skb->len, PCI_DMA_TODEVICE);
1345 dev_kfree_skb(skb);
1346 } else {
1347 pci_unmap_single(de->pdev,
1348 de->tx_skb[i].mapping,
1349 sizeof(de->setup_frame),
1350 PCI_DMA_TODEVICE);
1351 }
1352 }
1353 }
1354
1355 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1356 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1357 }
1358
1359 static void de_free_rings (struct de_private *de)
1360 {
1361 de_clean_rings(de);
1362 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1363 de->rx_ring = NULL;
1364 de->tx_ring = NULL;
1365 }
1366
1367 static int de_open (struct net_device *dev)
1368 {
1369 struct de_private *de = netdev_priv(dev);
1370 int rc;
1371
1372 if (netif_msg_ifup(de))
1373 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1374
1375 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1376
1377 rc = de_alloc_rings(de);
1378 if (rc) {
1379 printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
1380 dev->name, rc);
1381 return rc;
1382 }
1383
1384 dw32(IntrMask, 0);
1385
1386 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1387 if (rc) {
1388 printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
1389 dev->name, dev->irq, rc);
1390 goto err_out_free;
1391 }
1392
1393 rc = de_init_hw(de);
1394 if (rc) {
1395 printk(KERN_ERR "%s: h/w init failure, err=%d\n",
1396 dev->name, rc);
1397 goto err_out_free_irq;
1398 }
1399
1400 netif_start_queue(dev);
1401 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1402
1403 return 0;
1404
1405 err_out_free_irq:
1406 free_irq(dev->irq, dev);
1407 err_out_free:
1408 de_free_rings(de);
1409 return rc;
1410 }
1411
1412 static int de_close (struct net_device *dev)
1413 {
1414 struct de_private *de = netdev_priv(dev);
1415 unsigned long flags;
1416
1417 if (netif_msg_ifdown(de))
1418 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1419
1420 del_timer_sync(&de->media_timer);
1421
1422 spin_lock_irqsave(&de->lock, flags);
1423 de_stop_hw(de);
1424 netif_stop_queue(dev);
1425 netif_carrier_off(dev);
1426 spin_unlock_irqrestore(&de->lock, flags);
1427
1428 free_irq(dev->irq, dev);
1429
1430 de_free_rings(de);
1431 de_adapter_sleep(de);
1432 return 0;
1433 }
1434
1435 static void de_tx_timeout (struct net_device *dev)
1436 {
1437 struct de_private *de = netdev_priv(dev);
1438
1439 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1440 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1441 de->rx_tail, de->tx_head, de->tx_tail);
1442
1443 del_timer_sync(&de->media_timer);
1444
1445 disable_irq(dev->irq);
1446 spin_lock_irq(&de->lock);
1447
1448 de_stop_hw(de);
1449 netif_stop_queue(dev);
1450 netif_carrier_off(dev);
1451
1452 spin_unlock_irq(&de->lock);
1453 enable_irq(dev->irq);
1454
1455 /* Update the error counts. */
1456 __de_get_stats(de);
1457
1458 synchronize_irq(dev->irq);
1459 de_clean_rings(de);
1460
1461 de_init_rings(de);
1462
1463 de_init_hw(de);
1464
1465 netif_wake_queue(dev);
1466 }
1467
1468 static void __de_get_regs(struct de_private *de, u8 *buf)
1469 {
1470 int i;
1471 u32 *rbuf = (u32 *)buf;
1472
1473 /* read all CSRs */
1474 for (i = 0; i < DE_NUM_REGS; i++)
1475 rbuf[i] = dr32(i * 8);
1476
1477 /* handle self-clearing RxMissed counter, CSR8 */
1478 de_rx_missed(de, rbuf[8]);
1479 }
1480
1481 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1482 {
1483 ecmd->supported = de->media_supported;
1484 ecmd->transceiver = XCVR_INTERNAL;
1485 ecmd->phy_address = 0;
1486 ecmd->advertising = de->media_advertise;
1487
1488 switch (de->media_type) {
1489 case DE_MEDIA_AUI:
1490 ecmd->port = PORT_AUI;
1491 ecmd->speed = 5;
1492 break;
1493 case DE_MEDIA_BNC:
1494 ecmd->port = PORT_BNC;
1495 ecmd->speed = 2;
1496 break;
1497 default:
1498 ecmd->port = PORT_TP;
1499 ecmd->speed = SPEED_10;
1500 break;
1501 }
1502
1503 if (dr32(MacMode) & FullDuplex)
1504 ecmd->duplex = DUPLEX_FULL;
1505 else
1506 ecmd->duplex = DUPLEX_HALF;
1507
1508 if (de->media_lock)
1509 ecmd->autoneg = AUTONEG_DISABLE;
1510 else
1511 ecmd->autoneg = AUTONEG_ENABLE;
1512
1513 /* ignore maxtxpkt, maxrxpkt for now */
1514
1515 return 0;
1516 }
1517
1518 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1519 {
1520 u32 new_media;
1521 unsigned int media_lock;
1522
1523 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1524 return -EINVAL;
1525 if (de->de21040 && ecmd->speed == 2)
1526 return -EINVAL;
1527 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1528 return -EINVAL;
1529 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1530 return -EINVAL;
1531 if (de->de21040 && ecmd->port == PORT_BNC)
1532 return -EINVAL;
1533 if (ecmd->transceiver != XCVR_INTERNAL)
1534 return -EINVAL;
1535 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1536 return -EINVAL;
1537 if (ecmd->advertising & ~de->media_supported)
1538 return -EINVAL;
1539 if (ecmd->autoneg == AUTONEG_ENABLE &&
1540 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1541 return -EINVAL;
1542
1543 switch (ecmd->port) {
1544 case PORT_AUI:
1545 new_media = DE_MEDIA_AUI;
1546 if (!(ecmd->advertising & ADVERTISED_AUI))
1547 return -EINVAL;
1548 break;
1549 case PORT_BNC:
1550 new_media = DE_MEDIA_BNC;
1551 if (!(ecmd->advertising & ADVERTISED_BNC))
1552 return -EINVAL;
1553 break;
1554 default:
1555 if (ecmd->autoneg == AUTONEG_ENABLE)
1556 new_media = DE_MEDIA_TP_AUTO;
1557 else if (ecmd->duplex == DUPLEX_FULL)
1558 new_media = DE_MEDIA_TP_FD;
1559 else
1560 new_media = DE_MEDIA_TP;
1561 if (!(ecmd->advertising & ADVERTISED_TP))
1562 return -EINVAL;
1563 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1564 return -EINVAL;
1565 break;
1566 }
1567
1568 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1569
1570 if ((new_media == de->media_type) &&
1571 (media_lock == de->media_lock) &&
1572 (ecmd->advertising == de->media_advertise))
1573 return 0; /* nothing to change */
1574
1575 de_link_down(de);
1576 de_stop_rxtx(de);
1577
1578 de->media_type = new_media;
1579 de->media_lock = media_lock;
1580 de->media_advertise = ecmd->advertising;
1581 de_set_media(de);
1582
1583 return 0;
1584 }
1585
1586 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1587 {
1588 struct de_private *de = netdev_priv(dev);
1589
1590 strcpy (info->driver, DRV_NAME);
1591 strcpy (info->version, DRV_VERSION);
1592 strcpy (info->bus_info, pci_name(de->pdev));
1593 info->eedump_len = DE_EEPROM_SIZE;
1594 }
1595
1596 static int de_get_regs_len(struct net_device *dev)
1597 {
1598 return DE_REGS_SIZE;
1599 }
1600
1601 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1602 {
1603 struct de_private *de = netdev_priv(dev);
1604 int rc;
1605
1606 spin_lock_irq(&de->lock);
1607 rc = __de_get_settings(de, ecmd);
1608 spin_unlock_irq(&de->lock);
1609
1610 return rc;
1611 }
1612
1613 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1614 {
1615 struct de_private *de = netdev_priv(dev);
1616 int rc;
1617
1618 spin_lock_irq(&de->lock);
1619 rc = __de_set_settings(de, ecmd);
1620 spin_unlock_irq(&de->lock);
1621
1622 return rc;
1623 }
1624
1625 static u32 de_get_msglevel(struct net_device *dev)
1626 {
1627 struct de_private *de = netdev_priv(dev);
1628
1629 return de->msg_enable;
1630 }
1631
1632 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1633 {
1634 struct de_private *de = netdev_priv(dev);
1635
1636 de->msg_enable = msglvl;
1637 }
1638
1639 static int de_get_eeprom(struct net_device *dev,
1640 struct ethtool_eeprom *eeprom, u8 *data)
1641 {
1642 struct de_private *de = netdev_priv(dev);
1643
1644 if (!de->ee_data)
1645 return -EOPNOTSUPP;
1646 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1647 (eeprom->len != DE_EEPROM_SIZE))
1648 return -EINVAL;
1649 memcpy(data, de->ee_data, eeprom->len);
1650
1651 return 0;
1652 }
1653
1654 static int de_nway_reset(struct net_device *dev)
1655 {
1656 struct de_private *de = netdev_priv(dev);
1657 u32 status;
1658
1659 if (de->media_type != DE_MEDIA_TP_AUTO)
1660 return -EINVAL;
1661 if (netif_carrier_ok(de->dev))
1662 de_link_down(de);
1663
1664 status = dr32(SIAStatus);
1665 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1666 if (netif_msg_link(de))
1667 printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
1668 de->dev->name, status, dr32(SIAStatus));
1669 return 0;
1670 }
1671
1672 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1673 void *data)
1674 {
1675 struct de_private *de = netdev_priv(dev);
1676
1677 regs->version = (DE_REGS_VER << 2) | de->de21040;
1678
1679 spin_lock_irq(&de->lock);
1680 __de_get_regs(de, data);
1681 spin_unlock_irq(&de->lock);
1682 }
1683
1684 static const struct ethtool_ops de_ethtool_ops = {
1685 .get_link = ethtool_op_get_link,
1686 .get_drvinfo = de_get_drvinfo,
1687 .get_regs_len = de_get_regs_len,
1688 .get_settings = de_get_settings,
1689 .set_settings = de_set_settings,
1690 .get_msglevel = de_get_msglevel,
1691 .set_msglevel = de_set_msglevel,
1692 .get_eeprom = de_get_eeprom,
1693 .nway_reset = de_nway_reset,
1694 .get_regs = de_get_regs,
1695 };
1696
1697 static void __devinit de21040_get_mac_address (struct de_private *de)
1698 {
1699 unsigned i;
1700
1701 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1702 udelay(5);
1703
1704 for (i = 0; i < 6; i++) {
1705 int value, boguscnt = 100000;
1706 do {
1707 value = dr32(ROMCmd);
1708 } while (value < 0 && --boguscnt > 0);
1709 de->dev->dev_addr[i] = value;
1710 udelay(1);
1711 if (boguscnt <= 0)
1712 printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
1713 }
1714 }
1715
1716 static void __devinit de21040_get_media_info(struct de_private *de)
1717 {
1718 unsigned int i;
1719
1720 de->media_type = DE_MEDIA_TP;
1721 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1722 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1723 de->media_advertise = de->media_supported;
1724
1725 for (i = 0; i < DE_MAX_MEDIA; i++) {
1726 switch (i) {
1727 case DE_MEDIA_AUI:
1728 case DE_MEDIA_TP:
1729 case DE_MEDIA_TP_FD:
1730 de->media[i].type = i;
1731 de->media[i].csr13 = t21040_csr13[i];
1732 de->media[i].csr14 = t21040_csr14[i];
1733 de->media[i].csr15 = t21040_csr15[i];
1734 break;
1735 default:
1736 de->media[i].type = DE_MEDIA_INVALID;
1737 break;
1738 }
1739 }
1740 }
1741
1742 /* Note: this routine returns extra data bits for size detection. */
1743 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1744 {
1745 int i;
1746 unsigned retval = 0;
1747 void __iomem *ee_addr = regs + ROMCmd;
1748 int read_cmd = location | (EE_READ_CMD << addr_len);
1749
1750 writel(EE_ENB & ~EE_CS, ee_addr);
1751 writel(EE_ENB, ee_addr);
1752
1753 /* Shift the read command bits out. */
1754 for (i = 4 + addr_len; i >= 0; i--) {
1755 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1756 writel(EE_ENB | dataval, ee_addr);
1757 readl(ee_addr);
1758 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1759 readl(ee_addr);
1760 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1761 }
1762 writel(EE_ENB, ee_addr);
1763 readl(ee_addr);
1764
1765 for (i = 16; i > 0; i--) {
1766 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1767 readl(ee_addr);
1768 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1769 writel(EE_ENB, ee_addr);
1770 readl(ee_addr);
1771 }
1772
1773 /* Terminate the EEPROM access. */
1774 writel(EE_ENB & ~EE_CS, ee_addr);
1775 return retval;
1776 }
1777
1778 static void __devinit de21041_get_srom_info (struct de_private *de)
1779 {
1780 unsigned i, sa_offset = 0, ofs;
1781 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1782 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1783 struct de_srom_info_leaf *il;
1784 void *bufp;
1785
1786 /* download entire eeprom */
1787 for (i = 0; i < DE_EEPROM_WORDS; i++)
1788 ((__le16 *)ee_data)[i] =
1789 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1790
1791 /* DEC now has a specification but early board makers
1792 just put the address in the first EEPROM locations. */
1793 /* This does memcmp(eedata, eedata+16, 8) */
1794
1795 #ifndef CONFIG_MIPS_COBALT
1796
1797 for (i = 0; i < 8; i ++)
1798 if (ee_data[i] != ee_data[16+i])
1799 sa_offset = 20;
1800
1801 #endif
1802
1803 /* store MAC address */
1804 for (i = 0; i < 6; i ++)
1805 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1806
1807 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1808 ofs = ee_data[SROMC0InfoLeaf];
1809 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1810 goto bad_srom;
1811
1812 /* get pointer to info leaf */
1813 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1814
1815 /* paranoia checks */
1816 if (il->n_blocks == 0)
1817 goto bad_srom;
1818 if ((sizeof(ee_data) - ofs) <
1819 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1820 goto bad_srom;
1821
1822 /* get default media type */
1823 switch (get_unaligned(&il->default_media)) {
1824 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1825 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1826 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1827 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1828 }
1829
1830 if (netif_msg_probe(de))
1831 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1832 de->board_idx, ofs,
1833 media_name[de->media_type]);
1834
1835 /* init SIA register values to defaults */
1836 for (i = 0; i < DE_MAX_MEDIA; i++) {
1837 de->media[i].type = DE_MEDIA_INVALID;
1838 de->media[i].csr13 = 0xffff;
1839 de->media[i].csr14 = 0xffff;
1840 de->media[i].csr15 = 0xffff;
1841 }
1842
1843 /* parse media blocks to see what medias are supported,
1844 * and if any custom CSR values are provided
1845 */
1846 bufp = ((void *)il) + sizeof(*il);
1847 for (i = 0; i < il->n_blocks; i++) {
1848 struct de_srom_media_block *ib = bufp;
1849 unsigned idx;
1850
1851 /* index based on media type in media block */
1852 switch(ib->opts & MediaBlockMask) {
1853 case 0: /* 10baseT */
1854 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1855 | SUPPORTED_Autoneg;
1856 idx = DE_MEDIA_TP;
1857 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1858 break;
1859 case 1: /* BNC */
1860 de->media_supported |= SUPPORTED_BNC;
1861 idx = DE_MEDIA_BNC;
1862 break;
1863 case 2: /* AUI */
1864 de->media_supported |= SUPPORTED_AUI;
1865 idx = DE_MEDIA_AUI;
1866 break;
1867 case 4: /* 10baseT-FD */
1868 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1869 | SUPPORTED_Autoneg;
1870 idx = DE_MEDIA_TP_FD;
1871 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1872 break;
1873 default:
1874 goto bad_srom;
1875 }
1876
1877 de->media[idx].type = idx;
1878
1879 if (netif_msg_probe(de))
1880 printk(KERN_INFO "de%d: media block #%u: %s",
1881 de->board_idx, i,
1882 media_name[de->media[idx].type]);
1883
1884 bufp += sizeof (ib->opts);
1885
1886 if (ib->opts & MediaCustomCSRs) {
1887 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1888 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1889 de->media[idx].csr15 = get_unaligned(&ib->csr15);
1890 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1891 sizeof(ib->csr15);
1892
1893 if (netif_msg_probe(de))
1894 printk(" (%x,%x,%x)\n",
1895 de->media[idx].csr13,
1896 de->media[idx].csr14,
1897 de->media[idx].csr15);
1898
1899 } else if (netif_msg_probe(de))
1900 printk("\n");
1901
1902 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1903 break;
1904 }
1905
1906 de->media_advertise = de->media_supported;
1907
1908 fill_defaults:
1909 /* fill in defaults, for cases where custom CSRs not used */
1910 for (i = 0; i < DE_MAX_MEDIA; i++) {
1911 if (de->media[i].csr13 == 0xffff)
1912 de->media[i].csr13 = t21041_csr13[i];
1913 if (de->media[i].csr14 == 0xffff)
1914 de->media[i].csr14 = t21041_csr14[i];
1915 if (de->media[i].csr15 == 0xffff)
1916 de->media[i].csr15 = t21041_csr15[i];
1917 }
1918
1919 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1920
1921 return;
1922
1923 bad_srom:
1924 /* for error cases, it's ok to assume we support all these */
1925 for (i = 0; i < DE_MAX_MEDIA; i++)
1926 de->media[i].type = i;
1927 de->media_supported =
1928 SUPPORTED_10baseT_Half |
1929 SUPPORTED_10baseT_Full |
1930 SUPPORTED_Autoneg |
1931 SUPPORTED_TP |
1932 SUPPORTED_AUI |
1933 SUPPORTED_BNC;
1934 goto fill_defaults;
1935 }
1936
1937 static const struct net_device_ops de_netdev_ops = {
1938 .ndo_open = de_open,
1939 .ndo_stop = de_close,
1940 .ndo_set_multicast_list = de_set_rx_mode,
1941 .ndo_start_xmit = de_start_xmit,
1942 .ndo_get_stats = de_get_stats,
1943 .ndo_tx_timeout = de_tx_timeout,
1944 .ndo_change_mtu = eth_change_mtu,
1945 .ndo_set_mac_address = eth_mac_addr,
1946 .ndo_validate_addr = eth_validate_addr,
1947 };
1948
1949 static int __devinit de_init_one (struct pci_dev *pdev,
1950 const struct pci_device_id *ent)
1951 {
1952 struct net_device *dev;
1953 struct de_private *de;
1954 int rc;
1955 void __iomem *regs;
1956 unsigned long pciaddr;
1957 static int board_idx = -1;
1958
1959 board_idx++;
1960
1961 #ifndef MODULE
1962 if (board_idx == 0)
1963 printk("%s", version);
1964 #endif
1965
1966 /* allocate a new ethernet device structure, and fill in defaults */
1967 dev = alloc_etherdev(sizeof(struct de_private));
1968 if (!dev)
1969 return -ENOMEM;
1970
1971 dev->netdev_ops = &de_netdev_ops;
1972 SET_NETDEV_DEV(dev, &pdev->dev);
1973 dev->ethtool_ops = &de_ethtool_ops;
1974 dev->watchdog_timeo = TX_TIMEOUT;
1975
1976 de = netdev_priv(dev);
1977 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1978 de->pdev = pdev;
1979 de->dev = dev;
1980 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1981 de->board_idx = board_idx;
1982 spin_lock_init (&de->lock);
1983 init_timer(&de->media_timer);
1984 if (de->de21040)
1985 de->media_timer.function = de21040_media_timer;
1986 else
1987 de->media_timer.function = de21041_media_timer;
1988 de->media_timer.data = (unsigned long) de;
1989
1990 netif_carrier_off(dev);
1991 netif_stop_queue(dev);
1992
1993 /* wake up device, assign resources */
1994 rc = pci_enable_device(pdev);
1995 if (rc)
1996 goto err_out_free;
1997
1998 /* reserve PCI resources to ensure driver atomicity */
1999 rc = pci_request_regions(pdev, DRV_NAME);
2000 if (rc)
2001 goto err_out_disable;
2002
2003 /* check for invalid IRQ value */
2004 if (pdev->irq < 2) {
2005 rc = -EIO;
2006 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
2007 pdev->irq, pci_name(pdev));
2008 goto err_out_res;
2009 }
2010
2011 dev->irq = pdev->irq;
2012
2013 /* obtain and check validity of PCI I/O address */
2014 pciaddr = pci_resource_start(pdev, 1);
2015 if (!pciaddr) {
2016 rc = -EIO;
2017 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
2018 pci_name(pdev));
2019 goto err_out_res;
2020 }
2021 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2022 rc = -EIO;
2023 printk(KERN_ERR PFX "MMIO resource (%llx) too small on pci dev %s\n",
2024 (unsigned long long)pci_resource_len(pdev, 1), pci_name(pdev));
2025 goto err_out_res;
2026 }
2027
2028 /* remap CSR registers */
2029 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2030 if (!regs) {
2031 rc = -EIO;
2032 printk(KERN_ERR PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2033 (unsigned long long)pci_resource_len(pdev, 1),
2034 pciaddr, pci_name(pdev));
2035 goto err_out_res;
2036 }
2037 dev->base_addr = (unsigned long) regs;
2038 de->regs = regs;
2039
2040 de_adapter_wake(de);
2041
2042 /* make sure hardware is not running */
2043 rc = de_reset_mac(de);
2044 if (rc) {
2045 printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
2046 pci_name(pdev));
2047 goto err_out_iomap;
2048 }
2049
2050 /* get MAC address, initialize default media type and
2051 * get list of supported media
2052 */
2053 if (de->de21040) {
2054 de21040_get_mac_address(de);
2055 de21040_get_media_info(de);
2056 } else {
2057 de21041_get_srom_info(de);
2058 }
2059
2060 /* register new network interface with kernel */
2061 rc = register_netdev(dev);
2062 if (rc)
2063 goto err_out_iomap;
2064
2065 /* print info about board and interface just registered */
2066 printk (KERN_INFO "%s: %s at 0x%lx, %pM, IRQ %d\n",
2067 dev->name,
2068 de->de21040 ? "21040" : "21041",
2069 dev->base_addr,
2070 dev->dev_addr,
2071 dev->irq);
2072
2073 pci_set_drvdata(pdev, dev);
2074
2075 /* enable busmastering */
2076 pci_set_master(pdev);
2077
2078 /* put adapter to sleep */
2079 de_adapter_sleep(de);
2080
2081 return 0;
2082
2083 err_out_iomap:
2084 kfree(de->ee_data);
2085 iounmap(regs);
2086 err_out_res:
2087 pci_release_regions(pdev);
2088 err_out_disable:
2089 pci_disable_device(pdev);
2090 err_out_free:
2091 free_netdev(dev);
2092 return rc;
2093 }
2094
2095 static void __devexit de_remove_one (struct pci_dev *pdev)
2096 {
2097 struct net_device *dev = pci_get_drvdata(pdev);
2098 struct de_private *de = netdev_priv(dev);
2099
2100 BUG_ON(!dev);
2101 unregister_netdev(dev);
2102 kfree(de->ee_data);
2103 iounmap(de->regs);
2104 pci_release_regions(pdev);
2105 pci_disable_device(pdev);
2106 pci_set_drvdata(pdev, NULL);
2107 free_netdev(dev);
2108 }
2109
2110 #ifdef CONFIG_PM
2111
2112 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2113 {
2114 struct net_device *dev = pci_get_drvdata (pdev);
2115 struct de_private *de = netdev_priv(dev);
2116
2117 rtnl_lock();
2118 if (netif_running (dev)) {
2119 del_timer_sync(&de->media_timer);
2120
2121 disable_irq(dev->irq);
2122 spin_lock_irq(&de->lock);
2123
2124 de_stop_hw(de);
2125 netif_stop_queue(dev);
2126 netif_device_detach(dev);
2127 netif_carrier_off(dev);
2128
2129 spin_unlock_irq(&de->lock);
2130 enable_irq(dev->irq);
2131
2132 /* Update the error counts. */
2133 __de_get_stats(de);
2134
2135 synchronize_irq(dev->irq);
2136 de_clean_rings(de);
2137
2138 de_adapter_sleep(de);
2139 pci_disable_device(pdev);
2140 } else {
2141 netif_device_detach(dev);
2142 }
2143 rtnl_unlock();
2144 return 0;
2145 }
2146
2147 static int de_resume (struct pci_dev *pdev)
2148 {
2149 struct net_device *dev = pci_get_drvdata (pdev);
2150 struct de_private *de = netdev_priv(dev);
2151 int retval = 0;
2152
2153 rtnl_lock();
2154 if (netif_device_present(dev))
2155 goto out;
2156 if (!netif_running(dev))
2157 goto out_attach;
2158 if ((retval = pci_enable_device(pdev))) {
2159 printk (KERN_ERR "%s: pci_enable_device failed in resume\n",
2160 dev->name);
2161 goto out;
2162 }
2163 de_init_hw(de);
2164 out_attach:
2165 netif_device_attach(dev);
2166 out:
2167 rtnl_unlock();
2168 return 0;
2169 }
2170
2171 #endif /* CONFIG_PM */
2172
2173 static struct pci_driver de_driver = {
2174 .name = DRV_NAME,
2175 .id_table = de_pci_tbl,
2176 .probe = de_init_one,
2177 .remove = __devexit_p(de_remove_one),
2178 #ifdef CONFIG_PM
2179 .suspend = de_suspend,
2180 .resume = de_resume,
2181 #endif
2182 };
2183
2184 static int __init de_init (void)
2185 {
2186 #ifdef MODULE
2187 printk("%s", version);
2188 #endif
2189 return pci_register_driver(&de_driver);
2190 }
2191
2192 static void __exit de_exit (void)
2193 {
2194 pci_unregister_driver (&de_driver);
2195 }
2196
2197 module_init(de_init);
2198 module_exit(de_exit);
Support for the Chinese Samsung S3C2440 based development boards