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