?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.5.74.
[linux-2.6/linux-mips.git] / drivers / net / tulip / de2104x.c
blob85554686c161e4e14c855cd0c72c3a76de70304b
1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
2 /*
3 Copyright 2001 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.5.4"
32 #define DRV_RELDATE "Jan 1, 2002"
33
34 #include <linux/config.h>
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/init.h>
40 #include <linux/pci.h>
41 #include <linux/delay.h>
42 #include <linux/ethtool.h>
43 #include <linux/compiler.h>
44 #include <linux/rtnetlink.h>
45 #include <linux/crc32.h>
46
47 #include <asm/io.h>
48 #include <asm/irq.h>
49 #include <asm/uaccess.h>
50 #include <asm/unaligned.h>
51
52 /* These identify the driver base version and may not be removed. */
53 static char version[] __initdata =
54 KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
55
56 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
57 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
58 MODULE_LICENSE("GPL");
59
60 static int debug = -1;
61 MODULE_PARM (debug, "i");
62 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
63
64 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
65 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
66 || defined(__sparc_) || defined(__ia64__) \
67 || defined(__sh__) || defined(__mips__)
68 static int rx_copybreak = 1518;
69 #else
70 static int rx_copybreak = 100;
71 #endif
72 MODULE_PARM (rx_copybreak, "i");
73 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
74
75 #define PFX DRV_NAME ": "
76
77 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
78 NETIF_MSG_PROBE | \
79 NETIF_MSG_LINK | \
80 NETIF_MSG_IFDOWN | \
81 NETIF_MSG_IFUP | \
82 NETIF_MSG_RX_ERR | \
83 NETIF_MSG_TX_ERR)
84
85 #define DE_RX_RING_SIZE 64
86 #define DE_TX_RING_SIZE 64
87 #define DE_RING_BYTES \
88 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
89 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
90 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
91 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
92 #define TX_BUFFS_AVAIL(CP) \
93 (((CP)->tx_tail <= (CP)->tx_head) ? \
94 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
95 (CP)->tx_tail - (CP)->tx_head - 1)
96
97 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
98 #define RX_OFFSET 2
99
100 #define DE_SETUP_SKB ((struct sk_buff *) 1)
101 #define DE_DUMMY_SKB ((struct sk_buff *) 2)
102 #define DE_SETUP_FRAME_WORDS 96
103 #define DE_EEPROM_WORDS 256
104 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
105 #define DE_MAX_MEDIA 5
106
107 #define DE_MEDIA_TP_AUTO 0
108 #define DE_MEDIA_BNC 1
109 #define DE_MEDIA_AUI 2
110 #define DE_MEDIA_TP 3
111 #define DE_MEDIA_TP_FD 4
112 #define DE_MEDIA_INVALID DE_MAX_MEDIA
113 #define DE_MEDIA_FIRST 0
114 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
115 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
116
117 #define DE_TIMER_LINK (60 * HZ)
118 #define DE_TIMER_NO_LINK (5 * HZ)
119
120 #define DE_NUM_REGS 16
121 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
122 #define DE_REGS_VER 1
123
124 /* Time in jiffies before concluding the transmitter is hung. */
125 #define TX_TIMEOUT (6*HZ)
126
127 #define DE_UNALIGNED_16(a) (u16)(get_unaligned((u16 *)(a)))
128
129 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
130 to support a pre-NWay full-duplex signaling mechanism using short frames.
131 No one knows what it should be, but if left at its default value some
132 10base2(!) packets trigger a full-duplex-request interrupt. */
133 #define FULL_DUPLEX_MAGIC 0x6969
134
135 enum {
136 /* NIC registers */
137 BusMode = 0x00,
138 TxPoll = 0x08,
139 RxPoll = 0x10,
140 RxRingAddr = 0x18,
141 TxRingAddr = 0x20,
142 MacStatus = 0x28,
143 MacMode = 0x30,
144 IntrMask = 0x38,
145 RxMissed = 0x40,
146 ROMCmd = 0x48,
147 CSR11 = 0x58,
148 SIAStatus = 0x60,
149 CSR13 = 0x68,
150 CSR14 = 0x70,
151 CSR15 = 0x78,
152 PCIPM = 0x40,
153
154 /* BusMode bits */
155 CmdReset = (1 << 0),
156 CacheAlign16 = 0x00008000,
157 BurstLen4 = 0x00000400,
158
159 /* Rx/TxPoll bits */
160 NormalTxPoll = (1 << 0),
161 NormalRxPoll = (1 << 0),
162
163 /* Tx/Rx descriptor status bits */
164 DescOwn = (1 << 31),
165 RxError = (1 << 15),
166 RxErrLong = (1 << 7),
167 RxErrCRC = (1 << 1),
168 RxErrFIFO = (1 << 0),
169 RxErrRunt = (1 << 11),
170 RxErrFrame = (1 << 14),
171 RingEnd = (1 << 25),
172 FirstFrag = (1 << 29),
173 LastFrag = (1 << 30),
174 TxError = (1 << 15),
175 TxFIFOUnder = (1 << 1),
176 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
177 TxMaxCol = (1 << 8),
178 TxOWC = (1 << 9),
179 TxJabber = (1 << 14),
180 SetupFrame = (1 << 27),
181 TxSwInt = (1 << 31),
182
183 /* MacStatus bits */
184 IntrOK = (1 << 16),
185 IntrErr = (1 << 15),
186 RxIntr = (1 << 6),
187 RxEmpty = (1 << 7),
188 TxIntr = (1 << 0),
189 TxEmpty = (1 << 2),
190 PciErr = (1 << 13),
191 TxState = (1 << 22) | (1 << 21) | (1 << 20),
192 RxState = (1 << 19) | (1 << 18) | (1 << 17),
193 LinkFail = (1 << 12),
194 LinkPass = (1 << 4),
195 RxStopped = (1 << 8),
196 TxStopped = (1 << 1),
197
198 /* MacMode bits */
199 TxEnable = (1 << 13),
200 RxEnable = (1 << 1),
201 RxTx = TxEnable | RxEnable,
202 FullDuplex = (1 << 9),
203 AcceptAllMulticast = (1 << 7),
204 AcceptAllPhys = (1 << 6),
205 BOCnt = (1 << 5),
206 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
207 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
208
209 /* ROMCmd bits */
210 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
211 EE_CS = 0x01, /* EEPROM chip select. */
212 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
213 EE_WRITE_0 = 0x01,
214 EE_WRITE_1 = 0x05,
215 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
216 EE_ENB = (0x4800 | EE_CS),
217
218 /* The EEPROM commands include the alway-set leading bit. */
219 EE_READ_CMD = 6,
220
221 /* RxMissed bits */
222 RxMissedOver = (1 << 16),
223 RxMissedMask = 0xffff,
224
225 /* SROM-related bits */
226 SROMC0InfoLeaf = 27,
227 MediaBlockMask = 0x3f,
228 MediaCustomCSRs = (1 << 6),
229
230 /* PCIPM bits */
231 PM_Sleep = (1 << 31),
232 PM_Snooze = (1 << 30),
233 PM_Mask = PM_Sleep | PM_Snooze,
234
235 /* SIAStatus bits */
236 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
237 NWayRestart = (1 << 12),
238 NonselPortActive = (1 << 9),
239 LinkFailStatus = (1 << 2),
240 NetCxnErr = (1 << 1),
241 };
242
243 static const u32 de_intr_mask =
244 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
245 LinkPass | LinkFail | PciErr;
246
247 /*
248 * Set the programmable burst length to 4 longwords for all:
249 * DMA errors result without these values. Cache align 16 long.
250 */
251 static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
252
253 struct de_srom_media_block {
254 u8 opts;
255 u16 csr13;
256 u16 csr14;
257 u16 csr15;
258 } __attribute__((packed));
259
260 struct de_srom_info_leaf {
261 u16 default_media;
262 u8 n_blocks;
263 u8 unused;
264 } __attribute__((packed));
265
266 struct de_desc {
267 u32 opts1;
268 u32 opts2;
269 u32 addr1;
270 u32 addr2;
271 };
272
273 struct media_info {
274 u16 type; /* DE_MEDIA_xxx */
275 u16 csr13;
276 u16 csr14;
277 u16 csr15;
278 };
279
280 struct ring_info {
281 struct sk_buff *skb;
282 dma_addr_t mapping;
283 };
284
285 struct de_private {
286 unsigned tx_head;
287 unsigned tx_tail;
288 unsigned rx_tail;
289
290 void *regs;
291 struct net_device *dev;
292 spinlock_t lock;
293
294 struct de_desc *rx_ring;
295 struct de_desc *tx_ring;
296 struct ring_info tx_skb[DE_TX_RING_SIZE];
297 struct ring_info rx_skb[DE_RX_RING_SIZE];
298 unsigned rx_buf_sz;
299 dma_addr_t ring_dma;
300
301 u32 msg_enable;
302
303 struct net_device_stats net_stats;
304
305 struct pci_dev *pdev;
306 u32 macmode;
307
308 u16 setup_frame[DE_SETUP_FRAME_WORDS];
309
310 u32 media_type;
311 u32 media_supported;
312 u32 media_advertise;
313 struct media_info media[DE_MAX_MEDIA];
314 struct timer_list media_timer;
315
316 u8 *ee_data;
317 unsigned board_idx;
318 unsigned de21040 : 1;
319 unsigned media_lock : 1;
320 };
321
322
323 static void de_set_rx_mode (struct net_device *dev);
324 static void de_tx (struct de_private *de);
325 static void de_clean_rings (struct de_private *de);
326 static void de_media_interrupt (struct de_private *de, u32 status);
327 static void de21040_media_timer (unsigned long data);
328 static void de21041_media_timer (unsigned long data);
329 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
330
331
332 static struct pci_device_id de_pci_tbl[] __initdata = {
333 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
334 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
335 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
336 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
337 { },
338 };
339 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
340
341 static const char * const media_name[DE_MAX_MEDIA] = {
342 "10baseT auto",
343 "BNC",
344 "AUI",
345 "10baseT-HD",
346 "10baseT-FD"
347 };
348
349 /* 21040 transceiver register settings:
350 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
351 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
352 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
353 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
354
355 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
356 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
357 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
358 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
359
360
361 static inline unsigned long
362 msec_to_jiffies(unsigned long ms)
363 {
364 return (((ms)*HZ+999)/1000);
365 }
366
367
368 #define dr32(reg) readl(de->regs + (reg))
369 #define dw32(reg,val) writel((val), de->regs + (reg))
370
371
372 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
373 u32 status, u32 len)
374 {
375 if (netif_msg_rx_err (de))
376 printk (KERN_DEBUG
377 "%s: rx err, slot %d status 0x%x len %d\n",
378 de->dev->name, rx_tail, status, len);
379
380 if ((status & 0x38000300) != 0x0300) {
381 /* Ingore earlier buffers. */
382 if ((status & 0xffff) != 0x7fff) {
383 if (netif_msg_rx_err(de))
384 printk(KERN_WARNING "%s: Oversized Ethernet frame "
385 "spanned multiple buffers, status %8.8x!\n",
386 de->dev->name, status);
387 de->net_stats.rx_length_errors++;
388 }
389 } else if (status & RxError) {
390 /* There was a fatal error. */
391 de->net_stats.rx_errors++; /* end of a packet.*/
392 if (status & 0x0890) de->net_stats.rx_length_errors++;
393 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
394 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
395 }
396 }
397
398 static void de_rx (struct de_private *de)
399 {
400 unsigned rx_tail = de->rx_tail;
401 unsigned rx_work = DE_RX_RING_SIZE;
402 unsigned drop = 0;
403 int rc;
404
405 while (rx_work--) {
406 u32 status, len;
407 dma_addr_t mapping;
408 struct sk_buff *skb, *copy_skb;
409 unsigned copying_skb, buflen;
410
411 skb = de->rx_skb[rx_tail].skb;
412 if (!skb)
413 BUG();
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 copy_skb->dev = de->dev;
448
449 if (!copying_skb) {
450 pci_unmap_single(de->pdev, mapping,
451 buflen, PCI_DMA_FROMDEVICE);
452 skb_put(skb, len);
453
454 mapping =
455 de->rx_skb[rx_tail].mapping =
456 pci_map_single(de->pdev, copy_skb->tail,
457 buflen, PCI_DMA_FROMDEVICE);
458 de->rx_skb[rx_tail].skb = copy_skb;
459 } else {
460 pci_dma_sync_single(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
461 skb_reserve(copy_skb, RX_OFFSET);
462 memcpy(skb_put(copy_skb, len), skb->tail, len);
463
464 /* We'll reuse the original ring buffer. */
465 skb = copy_skb;
466 }
467
468 skb->protocol = eth_type_trans (skb, de->dev);
469
470 de->net_stats.rx_packets++;
471 de->net_stats.rx_bytes += skb->len;
472 de->dev->last_rx = jiffies;
473 rc = netif_rx (skb);
474 if (rc == NET_RX_DROP)
475 drop = 1;
476
477 rx_next:
478 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
479 if (rx_tail == (DE_RX_RING_SIZE - 1))
480 de->rx_ring[rx_tail].opts2 =
481 cpu_to_le32(RingEnd | de->rx_buf_sz);
482 else
483 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
484 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
485 rx_tail = NEXT_RX(rx_tail);
486 }
487
488 if (!rx_work)
489 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
490
491 de->rx_tail = rx_tail;
492 }
493
494 static irqreturn_t de_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
495 {
496 struct net_device *dev = dev_instance;
497 struct de_private *de = dev->priv;
498 u32 status;
499
500 status = dr32(MacStatus);
501 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
502 return IRQ_NONE;
503
504 if (netif_msg_intr(de))
505 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
506 dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
507
508 dw32(MacStatus, status);
509
510 if (status & (RxIntr | RxEmpty)) {
511 de_rx(de);
512 if (status & RxEmpty)
513 dw32(RxPoll, NormalRxPoll);
514 }
515
516 spin_lock(&de->lock);
517
518 if (status & (TxIntr | TxEmpty))
519 de_tx(de);
520
521 if (status & (LinkPass | LinkFail))
522 de_media_interrupt(de, status);
523
524 spin_unlock(&de->lock);
525
526 if (status & PciErr) {
527 u16 pci_status;
528
529 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
530 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
531 printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
532 dev->name, status, pci_status);
533 }
534
535 return IRQ_HANDLED;
536 }
537
538 static void de_tx (struct de_private *de)
539 {
540 unsigned tx_head = de->tx_head;
541 unsigned tx_tail = de->tx_tail;
542
543 while (tx_tail != tx_head) {
544 struct sk_buff *skb;
545 u32 status;
546
547 rmb();
548 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
549 if (status & DescOwn)
550 break;
551
552 skb = de->tx_skb[tx_tail].skb;
553 if (!skb)
554 BUG();
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 = dev->priv;
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 1;
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 = dev->priv;
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 = dev->priv;
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 = dev->priv;
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 = de->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 BUG();
799 if (TX_BUFFS_AVAIL(de) == 0)
800 netif_stop_queue(dev);
801
802 /* Trigger an immediate transmit demand. */
803 dw32(TxPoll, NormalTxPoll);
804
805 out:
806 if (macmode != de->macmode) {
807 dw32 (MacMode, macmode);
808 de->macmode = macmode;
809 }
810 }
811
812 static void de_set_rx_mode (struct net_device *dev)
813 {
814 unsigned long flags;
815 struct de_private *de = dev->priv;
816
817 spin_lock_irqsave (&de->lock, flags);
818 __de_set_rx_mode(dev);
819 spin_unlock_irqrestore (&de->lock, flags);
820 }
821
822 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
823 {
824 if (unlikely(rx_missed & RxMissedOver))
825 de->net_stats.rx_missed_errors += RxMissedMask;
826 else
827 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
828 }
829
830 static void __de_get_stats(struct de_private *de)
831 {
832 u32 tmp = dr32(RxMissed); /* self-clearing */
833
834 de_rx_missed(de, tmp);
835 }
836
837 static struct net_device_stats *de_get_stats(struct net_device *dev)
838 {
839 struct de_private *de = dev->priv;
840
841 /* The chip only need report frame silently dropped. */
842 spin_lock_irq(&de->lock);
843 if (netif_running(dev) && netif_device_present(dev))
844 __de_get_stats(de);
845 spin_unlock_irq(&de->lock);
846
847 return &de->net_stats;
848 }
849
850 static inline int de_is_running (struct de_private *de)
851 {
852 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
853 }
854
855 static void de_stop_rxtx (struct de_private *de)
856 {
857 u32 macmode;
858 unsigned int work = 1000;
859
860 macmode = dr32(MacMode);
861 if (macmode & RxTx) {
862 dw32(MacMode, macmode & ~RxTx);
863 dr32(MacMode);
864 }
865
866 while (--work > 0) {
867 if (!de_is_running(de))
868 return;
869 cpu_relax();
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
925 if (de_is_running(de))
926 BUG();
927
928 if (de->de21040)
929 dw32(CSR11, FULL_DUPLEX_MAGIC);
930 dw32(CSR13, 0); /* Reset phy */
931 dw32(CSR14, de->media[media].csr14);
932 dw32(CSR15, de->media[media].csr15);
933 dw32(CSR13, de->media[media].csr13);
934
935 /* must delay 10ms before writing to other registers,
936 * especially CSR6
937 */
938 mdelay(10);
939
940 if (media == DE_MEDIA_TP_FD)
941 de->macmode |= FullDuplex;
942 else
943 de->macmode &= ~FullDuplex;
944
945 if (netif_msg_link(de)) {
946 printk(KERN_INFO "%s: set link %s\n"
947 KERN_INFO "%s: mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
948 KERN_INFO "%s: set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
949 de->dev->name, media_name[media],
950 de->dev->name, dr32(MacMode), dr32(SIAStatus),
951 dr32(CSR13), dr32(CSR14), dr32(CSR15),
952 de->dev->name, de->macmode, de->media[media].csr13,
953 de->media[media].csr14, de->media[media].csr15);
954 }
955 }
956
957 static void de_next_media (struct de_private *de, u32 *media,
958 unsigned int n_media)
959 {
960 unsigned int i;
961
962 for (i = 0; i < n_media; i++) {
963 if (de_ok_to_advertise(de, media[i])) {
964 de->media_type = media[i];
965 return;
966 }
967 }
968 }
969
970 static void de21040_media_timer (unsigned long data)
971 {
972 struct de_private *de = (struct de_private *) data;
973 struct net_device *dev = de->dev;
974 u32 status = dr32(SIAStatus);
975 unsigned int carrier;
976 unsigned long flags;
977
978 carrier = (status & NetCxnErr) ? 0 : 1;
979
980 if (carrier) {
981 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
982 goto no_link_yet;
983
984 de->media_timer.expires = jiffies + DE_TIMER_LINK;
985 add_timer(&de->media_timer);
986 if (!netif_carrier_ok(dev))
987 de_link_up(de);
988 else
989 if (netif_msg_timer(de))
990 printk(KERN_INFO "%s: %s link ok, status %x\n",
991 dev->name, media_name[de->media_type],
992 status);
993 return;
994 }
995
996 de_link_down(de);
997
998 if (de->media_lock)
999 return;
1000
1001 if (de->media_type == DE_MEDIA_AUI) {
1002 u32 next_state = DE_MEDIA_TP;
1003 de_next_media(de, &next_state, 1);
1004 } else {
1005 u32 next_state = DE_MEDIA_AUI;
1006 de_next_media(de, &next_state, 1);
1007 }
1008
1009 spin_lock_irqsave(&de->lock, flags);
1010 de_stop_rxtx(de);
1011 spin_unlock_irqrestore(&de->lock, flags);
1012 de_set_media(de);
1013 de_start_rxtx(de);
1014
1015 no_link_yet:
1016 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1017 add_timer(&de->media_timer);
1018
1019 if (netif_msg_timer(de))
1020 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1021 dev->name, media_name[de->media_type], status);
1022 }
1023
1024 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1025 {
1026 switch (new_media) {
1027 case DE_MEDIA_TP_AUTO:
1028 if (!(de->media_advertise & ADVERTISED_Autoneg))
1029 return 0;
1030 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1031 return 0;
1032 break;
1033 case DE_MEDIA_BNC:
1034 if (!(de->media_advertise & ADVERTISED_BNC))
1035 return 0;
1036 break;
1037 case DE_MEDIA_AUI:
1038 if (!(de->media_advertise & ADVERTISED_AUI))
1039 return 0;
1040 break;
1041 case DE_MEDIA_TP:
1042 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1043 return 0;
1044 break;
1045 case DE_MEDIA_TP_FD:
1046 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1047 return 0;
1048 break;
1049 }
1050
1051 return 1;
1052 }
1053
1054 static void de21041_media_timer (unsigned long data)
1055 {
1056 struct de_private *de = (struct de_private *) data;
1057 struct net_device *dev = de->dev;
1058 u32 status = dr32(SIAStatus);
1059 unsigned int carrier;
1060 unsigned long flags;
1061
1062 carrier = (status & NetCxnErr) ? 0 : 1;
1063
1064 if (carrier) {
1065 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1066 de->media_type == DE_MEDIA_TP ||
1067 de->media_type == DE_MEDIA_TP_FD) &&
1068 (status & LinkFailStatus))
1069 goto no_link_yet;
1070
1071 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1072 add_timer(&de->media_timer);
1073 if (!netif_carrier_ok(dev))
1074 de_link_up(de);
1075 else
1076 if (netif_msg_timer(de))
1077 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1078 dev->name, media_name[de->media_type],
1079 dr32(MacMode), status);
1080 return;
1081 }
1082
1083 de_link_down(de);
1084
1085 /* if media type locked, don't switch media */
1086 if (de->media_lock)
1087 goto set_media;
1088
1089 /* if activity detected, use that as hint for new media type */
1090 if (status & NonselPortActive) {
1091 unsigned int have_media = 1;
1092
1093 /* if AUI/BNC selected, then activity is on TP port */
1094 if (de->media_type == DE_MEDIA_AUI ||
1095 de->media_type == DE_MEDIA_BNC) {
1096 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1097 de->media_type = DE_MEDIA_TP_AUTO;
1098 else
1099 have_media = 0;
1100 }
1101
1102 /* TP selected. If there is only TP and BNC, then it's BNC */
1103 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1104 de_ok_to_advertise(de, DE_MEDIA_BNC))
1105 de->media_type = DE_MEDIA_BNC;
1106
1107 /* TP selected. If there is only TP and AUI, then it's AUI */
1108 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1109 de_ok_to_advertise(de, DE_MEDIA_AUI))
1110 de->media_type = DE_MEDIA_AUI;
1111
1112 /* otherwise, ignore the hint */
1113 else
1114 have_media = 0;
1115
1116 if (have_media)
1117 goto set_media;
1118 }
1119
1120 /*
1121 * Absent or ambiguous activity hint, move to next advertised
1122 * media state. If de->media_type is left unchanged, this
1123 * simply resets the PHY and reloads the current media settings.
1124 */
1125 if (de->media_type == DE_MEDIA_AUI) {
1126 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1127 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1128 } else if (de->media_type == DE_MEDIA_BNC) {
1129 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1130 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1131 } else {
1132 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1133 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1134 }
1135
1136 set_media:
1137 spin_lock_irqsave(&de->lock, flags);
1138 de_stop_rxtx(de);
1139 spin_unlock_irqrestore(&de->lock, flags);
1140 de_set_media(de);
1141 de_start_rxtx(de);
1142
1143 no_link_yet:
1144 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1145 add_timer(&de->media_timer);
1146
1147 if (netif_msg_timer(de))
1148 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1149 dev->name, media_name[de->media_type], status);
1150 }
1151
1152 static void de_media_interrupt (struct de_private *de, u32 status)
1153 {
1154 if (status & LinkPass) {
1155 de_link_up(de);
1156 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1157 return;
1158 }
1159
1160 if (!(status & LinkFail))
1161 BUG();
1162
1163 if (netif_carrier_ok(de->dev)) {
1164 de_link_down(de);
1165 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1166 }
1167 }
1168
1169 static int de_reset_mac (struct de_private *de)
1170 {
1171 u32 status, tmp;
1172
1173 /*
1174 * Reset MAC. Copied from de4x5.c.
1175 */
1176
1177 tmp = dr32 (BusMode);
1178 if (tmp == 0xffffffff)
1179 return -ENODEV;
1180 mdelay (1);
1181
1182 dw32 (BusMode, tmp | CmdReset);
1183 mdelay (1);
1184
1185 dw32 (BusMode, tmp);
1186 mdelay (1);
1187
1188 for (tmp = 0; tmp < 5; tmp++) {
1189 dr32 (BusMode);
1190 mdelay (1);
1191 }
1192
1193 mdelay (1);
1194
1195 status = dr32(MacStatus);
1196 if (status & (RxState | TxState))
1197 return -EBUSY;
1198 if (status == 0xffffffff)
1199 return -ENODEV;
1200 return 0;
1201 }
1202
1203 static void de_adapter_wake (struct de_private *de)
1204 {
1205 u32 pmctl;
1206
1207 if (de->de21040)
1208 return;
1209
1210 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1211 if (pmctl & PM_Mask) {
1212 pmctl &= ~PM_Mask;
1213 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1214
1215 /* de4x5.c delays, so we do too */
1216 current->state = TASK_UNINTERRUPTIBLE;
1217 schedule_timeout(msec_to_jiffies(10));
1218 }
1219 }
1220
1221 static void de_adapter_sleep (struct de_private *de)
1222 {
1223 u32 pmctl;
1224
1225 if (de->de21040)
1226 return;
1227
1228 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1229 pmctl |= PM_Sleep;
1230 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1231 }
1232
1233 static int de_init_hw (struct de_private *de)
1234 {
1235 struct net_device *dev = de->dev;
1236 int rc;
1237
1238 de_adapter_wake(de);
1239
1240 de->macmode = dr32(MacMode) & ~MacModeClear;
1241
1242 rc = de_reset_mac(de);
1243 if (rc)
1244 return rc;
1245
1246 de_set_media(de); /* reset phy */
1247
1248 dw32(RxRingAddr, de->ring_dma);
1249 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1250
1251 dw32(MacMode, RxTx | de->macmode);
1252
1253 dr32(RxMissed); /* self-clearing */
1254
1255 dw32(IntrMask, de_intr_mask);
1256
1257 de_set_rx_mode(dev);
1258
1259 return 0;
1260 }
1261
1262 static int de_refill_rx (struct de_private *de)
1263 {
1264 unsigned i;
1265
1266 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1267 struct sk_buff *skb;
1268
1269 skb = dev_alloc_skb(de->rx_buf_sz);
1270 if (!skb)
1271 goto err_out;
1272
1273 skb->dev = de->dev;
1274
1275 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1276 skb->tail, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1277 de->rx_skb[i].skb = skb;
1278
1279 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1280 if (i == (DE_RX_RING_SIZE - 1))
1281 de->rx_ring[i].opts2 =
1282 cpu_to_le32(RingEnd | de->rx_buf_sz);
1283 else
1284 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1285 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1286 de->rx_ring[i].addr2 = 0;
1287 }
1288
1289 return 0;
1290
1291 err_out:
1292 de_clean_rings(de);
1293 return -ENOMEM;
1294 }
1295
1296 static int de_init_rings (struct de_private *de)
1297 {
1298 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1299 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1300
1301 de->rx_tail = 0;
1302 de->tx_head = de->tx_tail = 0;
1303
1304 return de_refill_rx (de);
1305 }
1306
1307 static int de_alloc_rings (struct de_private *de)
1308 {
1309 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1310 if (!de->rx_ring)
1311 return -ENOMEM;
1312 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1313 return de_init_rings(de);
1314 }
1315
1316 static void de_clean_rings (struct de_private *de)
1317 {
1318 unsigned i;
1319
1320 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1321 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1322 wmb();
1323 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1324 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1325 wmb();
1326
1327 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1328 if (de->rx_skb[i].skb) {
1329 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1330 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1331 dev_kfree_skb(de->rx_skb[i].skb);
1332 }
1333 }
1334
1335 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1336 struct sk_buff *skb = de->tx_skb[i].skb;
1337 if ((skb) && (skb != DE_DUMMY_SKB)) {
1338 if (skb != DE_SETUP_SKB) {
1339 dev_kfree_skb(skb);
1340 de->net_stats.tx_dropped++;
1341 pci_unmap_single(de->pdev,
1342 de->tx_skb[i].mapping,
1343 skb->len, PCI_DMA_TODEVICE);
1344 } else {
1345 pci_unmap_single(de->pdev,
1346 de->tx_skb[i].mapping,
1347 sizeof(de->setup_frame),
1348 PCI_DMA_TODEVICE);
1349 }
1350 }
1351 }
1352
1353 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1354 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1355 }
1356
1357 static void de_free_rings (struct de_private *de)
1358 {
1359 de_clean_rings(de);
1360 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1361 de->rx_ring = NULL;
1362 de->tx_ring = NULL;
1363 }
1364
1365 static int de_open (struct net_device *dev)
1366 {
1367 struct de_private *de = dev->priv;
1368 int rc;
1369 unsigned long flags;
1370
1371 if (netif_msg_ifup(de))
1372 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1373
1374 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1375
1376 rc = de_alloc_rings(de);
1377 if (rc) {
1378 printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
1379 dev->name, rc);
1380 return rc;
1381 }
1382
1383 rc = de_init_hw(de);
1384 if (rc) {
1385 printk(KERN_ERR "%s: h/w init failure, err=%d\n",
1386 dev->name, rc);
1387 goto err_out_free;
1388 }
1389
1390 rc = request_irq(dev->irq, de_interrupt, SA_SHIRQ, dev->name, dev);
1391 if (rc) {
1392 printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
1393 dev->name, dev->irq, rc);
1394 goto err_out_hw;
1395 }
1396
1397 netif_start_queue(dev);
1398 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1399
1400 return 0;
1401
1402 err_out_hw:
1403 spin_lock_irqsave(&de->lock, flags);
1404 de_stop_hw(de);
1405 spin_unlock_irqrestore(&de->lock, flags);
1406
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 = dev->priv;
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 pci_disable_device(de->pdev);
1433 return 0;
1434 }
1435
1436 static void de_tx_timeout (struct net_device *dev)
1437 {
1438 struct de_private *de = dev->priv;
1439
1440 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1441 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1442 de->rx_tail, de->tx_head, de->tx_tail);
1443
1444 del_timer_sync(&de->media_timer);
1445
1446 disable_irq(dev->irq);
1447 spin_lock_irq(&de->lock);
1448
1449 de_stop_hw(de);
1450 netif_stop_queue(dev);
1451 netif_carrier_off(dev);
1452
1453 spin_unlock_irq(&de->lock);
1454 enable_irq(dev->irq);
1455
1456 /* Update the error counts. */
1457 __de_get_stats(de);
1458
1459 synchronize_irq(dev->irq);
1460 de_clean_rings(de);
1461
1462 de_init_hw(de);
1463
1464 netif_wake_queue(dev);
1465 }
1466
1467 static int de_get_regs(struct de_private *de, u8 *buf)
1468 {
1469 int i;
1470 u32 *rbuf = (u32 *)buf;
1471
1472 /* read all CSRs */
1473 for (i = 0; i < DE_NUM_REGS; i++)
1474 rbuf[i] = dr32(i * 8);
1475
1476 /* handle self-clearing RxMissed counter, CSR8 */
1477 de_rx_missed(de, rbuf[8]);
1478
1479 return 0;
1480 }
1481
1482 static int de_ethtool_gset(struct de_private *de, struct ethtool_cmd *ecmd)
1483 {
1484 ecmd->supported = de->media_supported;
1485 ecmd->transceiver = XCVR_INTERNAL;
1486 ecmd->phy_address = 0;
1487 ecmd->advertising = de->media_advertise;
1488
1489 switch (de->media_type) {
1490 case DE_MEDIA_AUI:
1491 ecmd->port = PORT_AUI;
1492 ecmd->speed = 5;
1493 break;
1494 case DE_MEDIA_BNC:
1495 ecmd->port = PORT_BNC;
1496 ecmd->speed = 2;
1497 break;
1498 default:
1499 ecmd->port = PORT_TP;
1500 ecmd->speed = SPEED_10;
1501 break;
1502 }
1503
1504 if (de->macmode & FullDuplex)
1505 ecmd->duplex = DUPLEX_FULL;
1506 else
1507 ecmd->duplex = DUPLEX_HALF;
1508
1509 if (de->media_lock)
1510 ecmd->autoneg = AUTONEG_DISABLE;
1511 else
1512 ecmd->autoneg = AUTONEG_ENABLE;
1513
1514 /* ignore maxtxpkt, maxrxpkt for now */
1515
1516 return 0;
1517 }
1518
1519 static int de_ethtool_sset(struct de_private *de, struct ethtool_cmd *ecmd)
1520 {
1521 u32 new_media;
1522 unsigned int media_lock;
1523
1524 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1525 return -EINVAL;
1526 if (de->de21040 && ecmd->speed == 2)
1527 return -EINVAL;
1528 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1529 return -EINVAL;
1530 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1531 return -EINVAL;
1532 if (de->de21040 && ecmd->port == PORT_BNC)
1533 return -EINVAL;
1534 if (ecmd->transceiver != XCVR_INTERNAL)
1535 return -EINVAL;
1536 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1537 return -EINVAL;
1538 if (ecmd->advertising & ~de->media_supported)
1539 return -EINVAL;
1540 if (ecmd->autoneg == AUTONEG_ENABLE &&
1541 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1542 return -EINVAL;
1543
1544 switch (ecmd->port) {
1545 case PORT_AUI:
1546 new_media = DE_MEDIA_AUI;
1547 if (!(ecmd->advertising & ADVERTISED_AUI))
1548 return -EINVAL;
1549 break;
1550 case PORT_BNC:
1551 new_media = DE_MEDIA_BNC;
1552 if (!(ecmd->advertising & ADVERTISED_BNC))
1553 return -EINVAL;
1554 break;
1555 default:
1556 if (ecmd->autoneg == AUTONEG_ENABLE)
1557 new_media = DE_MEDIA_TP_AUTO;
1558 else if (ecmd->duplex == DUPLEX_FULL)
1559 new_media = DE_MEDIA_TP_FD;
1560 else
1561 new_media = DE_MEDIA_TP;
1562 if (!(ecmd->advertising & ADVERTISED_TP))
1563 return -EINVAL;
1564 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1565 return -EINVAL;
1566 break;
1567 }
1568
1569 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1570
1571 if ((new_media == de->media_type) &&
1572 (media_lock == de->media_lock) &&
1573 (ecmd->advertising == de->media_advertise))
1574 return 0; /* nothing to change */
1575
1576 de_link_down(de);
1577 de_stop_rxtx(de);
1578
1579 de->media_type = new_media;
1580 de->media_lock = media_lock;
1581 de->media_advertise = ecmd->advertising;
1582 de_set_media(de);
1583
1584 return 0;
1585 }
1586
1587 static int de_ethtool_ioctl (struct de_private *de, void *useraddr)
1588 {
1589 u32 ethcmd;
1590
1591 /* dev_ioctl() in ../../net/core/dev.c has already checked
1592 capable(CAP_NET_ADMIN), so don't bother with that here. */
1593
1594 if (get_user(ethcmd, (u32 *)useraddr))
1595 return -EFAULT;
1596
1597 switch (ethcmd) {
1598
1599 case ETHTOOL_GDRVINFO: {
1600 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1601 strcpy (info.driver, DRV_NAME);
1602 strcpy (info.version, DRV_VERSION);
1603 strcpy (info.bus_info, de->pdev->slot_name);
1604 info.eedump_len = DE_EEPROM_SIZE;
1605 info.regdump_len = DE_REGS_SIZE;
1606 if (copy_to_user (useraddr, &info, sizeof (info)))
1607 return -EFAULT;
1608 return 0;
1609 }
1610
1611 /* get settings */
1612 case ETHTOOL_GSET: {
1613 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1614 spin_lock_irq(&de->lock);
1615 de_ethtool_gset(de, &ecmd);
1616 spin_unlock_irq(&de->lock);
1617 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1618 return -EFAULT;
1619 return 0;
1620 }
1621 /* set settings */
1622 case ETHTOOL_SSET: {
1623 struct ethtool_cmd ecmd;
1624 int r;
1625 if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1626 return -EFAULT;
1627 spin_lock_irq(&de->lock);
1628 r = de_ethtool_sset(de, &ecmd);
1629 spin_unlock_irq(&de->lock);
1630 return r;
1631 }
1632
1633 /* restart autonegotiation */
1634 case ETHTOOL_NWAY_RST: {
1635 u32 status;
1636
1637 if (de->media_type != DE_MEDIA_TP_AUTO)
1638 return -EINVAL;
1639 if (netif_carrier_ok(de->dev))
1640 de_link_down(de);
1641
1642 status = dr32(SIAStatus);
1643 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1644 if (netif_msg_link(de))
1645 printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
1646 de->dev->name, status, dr32(SIAStatus));
1647 return 0;
1648 }
1649
1650 /* get link status */
1651 case ETHTOOL_GLINK: {
1652 struct ethtool_value edata = {ETHTOOL_GLINK};
1653 edata.data = (netif_carrier_ok(de->dev)) ? 1 : 0;
1654 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1655 return -EFAULT;
1656 return 0;
1657 }
1658
1659 /* get message-level */
1660 case ETHTOOL_GMSGLVL: {
1661 struct ethtool_value edata = {ETHTOOL_GMSGLVL};
1662 edata.data = de->msg_enable;
1663 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1664 return -EFAULT;
1665 return 0;
1666 }
1667 /* set message-level */
1668 case ETHTOOL_SMSGLVL: {
1669 struct ethtool_value edata;
1670 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1671 return -EFAULT;
1672 de->msg_enable = edata.data;
1673 return 0;
1674 }
1675
1676 /* get registers */
1677 case ETHTOOL_GREGS: {
1678 struct ethtool_regs regs;
1679 u8 regbuf[DE_REGS_SIZE];
1680 int r;
1681
1682 if (copy_from_user(&regs, useraddr, sizeof(regs)))
1683 return -EFAULT;
1684
1685 if (regs.len > DE_REGS_SIZE) {
1686 regs.len = DE_REGS_SIZE;
1687 }
1688 regs.version = (DE_REGS_VER << 2) | de->de21040;
1689 if (copy_to_user(useraddr, &regs, sizeof(regs)))
1690 return -EFAULT;
1691
1692 useraddr += offsetof(struct ethtool_regs, data);
1693
1694 spin_lock_irq(&de->lock);
1695 r = de_get_regs(de, regbuf);
1696 spin_unlock_irq(&de->lock);
1697
1698 if (r)
1699 return r;
1700 if (copy_to_user(useraddr, regbuf, regs.len))
1701 return -EFAULT;
1702 return 0;
1703 }
1704
1705 /* get SROM dump */
1706 case ETHTOOL_GEEPROM: {
1707 struct ethtool_eeprom eeprom;
1708
1709 if (!de->ee_data)
1710 break;
1711 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1712 return -EFAULT;
1713 if ((eeprom.offset != 0) || (eeprom.magic != 0) ||
1714 (eeprom.len != DE_EEPROM_SIZE))
1715 return -EINVAL;
1716
1717 useraddr += offsetof(struct ethtool_regs, data);
1718 if (copy_to_user(useraddr, de->ee_data, DE_EEPROM_SIZE))
1719 return -EFAULT;
1720 }
1721
1722 default:
1723 break;
1724 }
1725
1726 return -EOPNOTSUPP;
1727 }
1728
1729
1730 static int de_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1731 {
1732 struct de_private *de = dev->priv;
1733 int rc = 0;
1734
1735 if (!netif_running(dev))
1736 return -EINVAL;
1737
1738 switch (cmd) {
1739 case SIOCETHTOOL:
1740 return de_ethtool_ioctl(de, (void *) rq->ifr_data);
1741
1742 default:
1743 rc = -EOPNOTSUPP;
1744 break;
1745 }
1746
1747 return rc;
1748 }
1749
1750 static void __init de21040_get_mac_address (struct de_private *de)
1751 {
1752 unsigned i;
1753
1754 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1755
1756 for (i = 0; i < 6; i++) {
1757 int value, boguscnt = 100000;
1758 do
1759 value = dr32(ROMCmd);
1760 while (value < 0 && --boguscnt > 0);
1761 de->dev->dev_addr[i] = value;
1762 if (boguscnt <= 0)
1763 printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
1764 }
1765 }
1766
1767 static void __init de21040_get_media_info(struct de_private *de)
1768 {
1769 unsigned int i;
1770
1771 de->media_type = DE_MEDIA_TP;
1772 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1773 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1774 de->media_advertise = de->media_supported;
1775
1776 for (i = 0; i < DE_MAX_MEDIA; i++) {
1777 switch (i) {
1778 case DE_MEDIA_AUI:
1779 case DE_MEDIA_TP:
1780 case DE_MEDIA_TP_FD:
1781 de->media[i].type = i;
1782 de->media[i].csr13 = t21040_csr13[i];
1783 de->media[i].csr14 = t21040_csr14[i];
1784 de->media[i].csr15 = t21040_csr15[i];
1785 break;
1786 default:
1787 de->media[i].type = DE_MEDIA_INVALID;
1788 break;
1789 }
1790 }
1791 }
1792
1793 /* Note: this routine returns extra data bits for size detection. */
1794 static unsigned __init tulip_read_eeprom(void *regs, int location, int addr_len)
1795 {
1796 int i;
1797 unsigned retval = 0;
1798 void *ee_addr = regs + ROMCmd;
1799 int read_cmd = location | (EE_READ_CMD << addr_len);
1800
1801 writel(EE_ENB & ~EE_CS, ee_addr);
1802 writel(EE_ENB, ee_addr);
1803
1804 /* Shift the read command bits out. */
1805 for (i = 4 + addr_len; i >= 0; i--) {
1806 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1807 writel(EE_ENB | dataval, ee_addr);
1808 readl(ee_addr);
1809 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1810 readl(ee_addr);
1811 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1812 }
1813 writel(EE_ENB, ee_addr);
1814 readl(ee_addr);
1815
1816 for (i = 16; i > 0; i--) {
1817 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1818 readl(ee_addr);
1819 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1820 writel(EE_ENB, ee_addr);
1821 readl(ee_addr);
1822 }
1823
1824 /* Terminate the EEPROM access. */
1825 writel(EE_ENB & ~EE_CS, ee_addr);
1826 return retval;
1827 }
1828
1829 static void __init de21041_get_srom_info (struct de_private *de)
1830 {
1831 unsigned i, sa_offset = 0, ofs;
1832 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1833 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1834 struct de_srom_info_leaf *il;
1835 void *bufp;
1836
1837 /* download entire eeprom */
1838 for (i = 0; i < DE_EEPROM_WORDS; i++)
1839 ((u16 *)ee_data)[i] =
1840 le16_to_cpu(tulip_read_eeprom(de->regs, i, ee_addr_size));
1841
1842 /* DEC now has a specification but early board makers
1843 just put the address in the first EEPROM locations. */
1844 /* This does memcmp(eedata, eedata+16, 8) */
1845 for (i = 0; i < 8; i ++)
1846 if (ee_data[i] != ee_data[16+i])
1847 sa_offset = 20;
1848
1849 /* store MAC address */
1850 for (i = 0; i < 6; i ++)
1851 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1852
1853 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1854 ofs = ee_data[SROMC0InfoLeaf];
1855 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1856 goto bad_srom;
1857
1858 /* get pointer to info leaf */
1859 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1860
1861 /* paranoia checks */
1862 if (il->n_blocks == 0)
1863 goto bad_srom;
1864 if ((sizeof(ee_data) - ofs) <
1865 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1866 goto bad_srom;
1867
1868 /* get default media type */
1869 switch (DE_UNALIGNED_16(&il->default_media)) {
1870 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1871 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1872 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1873 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1874 }
1875
1876 if (netif_msg_probe(de))
1877 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1878 de->board_idx, ofs,
1879 media_name[de->media_type]);
1880
1881 /* init SIA register values to defaults */
1882 for (i = 0; i < DE_MAX_MEDIA; i++) {
1883 de->media[i].type = DE_MEDIA_INVALID;
1884 de->media[i].csr13 = 0xffff;
1885 de->media[i].csr14 = 0xffff;
1886 de->media[i].csr15 = 0xffff;
1887 }
1888
1889 /* parse media blocks to see what medias are supported,
1890 * and if any custom CSR values are provided
1891 */
1892 bufp = ((void *)il) + sizeof(*il);
1893 for (i = 0; i < il->n_blocks; i++) {
1894 struct de_srom_media_block *ib = bufp;
1895 unsigned idx;
1896
1897 /* index based on media type in media block */
1898 switch(ib->opts & MediaBlockMask) {
1899 case 0: /* 10baseT */
1900 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1901 | SUPPORTED_Autoneg;
1902 idx = DE_MEDIA_TP;
1903 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1904 break;
1905 case 1: /* BNC */
1906 de->media_supported |= SUPPORTED_BNC;
1907 idx = DE_MEDIA_BNC;
1908 break;
1909 case 2: /* AUI */
1910 de->media_supported |= SUPPORTED_AUI;
1911 idx = DE_MEDIA_AUI;
1912 break;
1913 case 4: /* 10baseT-FD */
1914 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1915 | SUPPORTED_Autoneg;
1916 idx = DE_MEDIA_TP_FD;
1917 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1918 break;
1919 default:
1920 goto bad_srom;
1921 }
1922
1923 de->media[idx].type = idx;
1924
1925 if (netif_msg_probe(de))
1926 printk(KERN_INFO "de%d: media block #%u: %s",
1927 de->board_idx, i,
1928 media_name[de->media[idx].type]);
1929
1930 bufp += sizeof (ib->opts);
1931
1932 if (ib->opts & MediaCustomCSRs) {
1933 de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
1934 de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1935 de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
1936 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1937 sizeof(ib->csr15);
1938
1939 if (netif_msg_probe(de))
1940 printk(" (%x,%x,%x)\n",
1941 de->media[idx].csr13,
1942 de->media[idx].csr14,
1943 de->media[idx].csr15);
1944
1945 } else if (netif_msg_probe(de))
1946 printk("\n");
1947
1948 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1949 break;
1950 }
1951
1952 de->media_advertise = de->media_supported;
1953
1954 fill_defaults:
1955 /* fill in defaults, for cases where custom CSRs not used */
1956 for (i = 0; i < DE_MAX_MEDIA; i++) {
1957 if (de->media[i].csr13 == 0xffff)
1958 de->media[i].csr13 = t21041_csr13[i];
1959 if (de->media[i].csr14 == 0xffff)
1960 de->media[i].csr14 = t21041_csr14[i];
1961 if (de->media[i].csr15 == 0xffff)
1962 de->media[i].csr15 = t21041_csr15[i];
1963 }
1964
1965 de->ee_data = kmalloc(DE_EEPROM_SIZE, GFP_KERNEL);
1966 if (de->ee_data)
1967 memcpy(de->ee_data, &ee_data[0], DE_EEPROM_SIZE);
1968
1969 return;
1970
1971 bad_srom:
1972 /* for error cases, it's ok to assume we support all these */
1973 for (i = 0; i < DE_MAX_MEDIA; i++)
1974 de->media[i].type = i;
1975 de->media_supported =
1976 SUPPORTED_10baseT_Half |
1977 SUPPORTED_10baseT_Full |
1978 SUPPORTED_Autoneg |
1979 SUPPORTED_TP |
1980 SUPPORTED_AUI |
1981 SUPPORTED_BNC;
1982 goto fill_defaults;
1983 }
1984
1985 static int __init de_init_one (struct pci_dev *pdev,
1986 const struct pci_device_id *ent)
1987 {
1988 struct net_device *dev;
1989 struct de_private *de;
1990 int rc;
1991 void *regs;
1992 long pciaddr;
1993 static int board_idx = -1;
1994
1995 board_idx++;
1996
1997 #ifndef MODULE
1998 if (board_idx == 0)
1999 printk("%s", version);
2000 #endif
2001
2002 /* allocate a new ethernet device structure, and fill in defaults */
2003 dev = alloc_etherdev(sizeof(struct de_private));
2004 if (!dev)
2005 return -ENOMEM;
2006
2007 SET_MODULE_OWNER(dev);
2008 SET_NETDEV_DEV(dev, &pdev->dev);
2009 dev->open = de_open;
2010 dev->stop = de_close;
2011 dev->set_multicast_list = de_set_rx_mode;
2012 dev->hard_start_xmit = de_start_xmit;
2013 dev->get_stats = de_get_stats;
2014 dev->do_ioctl = de_ioctl;
2015 dev->tx_timeout = de_tx_timeout;
2016 dev->watchdog_timeo = TX_TIMEOUT;
2017
2018 dev->irq = pdev->irq;
2019
2020 de = dev->priv;
2021 de->de21040 = ent->driver_data == 0 ? 1 : 0;
2022 de->pdev = pdev;
2023 de->dev = dev;
2024 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
2025 de->board_idx = board_idx;
2026 spin_lock_init (&de->lock);
2027 init_timer(&de->media_timer);
2028 if (de->de21040)
2029 de->media_timer.function = de21040_media_timer;
2030 else
2031 de->media_timer.function = de21041_media_timer;
2032 de->media_timer.data = (unsigned long) de;
2033
2034 netif_carrier_off(dev);
2035 netif_stop_queue(dev);
2036
2037 /* wake up device, assign resources */
2038 rc = pci_enable_device(pdev);
2039 if (rc)
2040 goto err_out_free;
2041
2042 /* reserve PCI resources to ensure driver atomicity */
2043 rc = pci_request_regions(pdev, DRV_NAME);
2044 if (rc)
2045 goto err_out_disable;
2046
2047 /* check for invalid IRQ value */
2048 if (pdev->irq < 2) {
2049 rc = -EIO;
2050 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
2051 pdev->irq, pdev->slot_name);
2052 goto err_out_res;
2053 }
2054
2055 /* obtain and check validity of PCI I/O address */
2056 pciaddr = pci_resource_start(pdev, 1);
2057 if (!pciaddr) {
2058 rc = -EIO;
2059 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
2060 pdev->slot_name);
2061 goto err_out_res;
2062 }
2063 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2064 rc = -EIO;
2065 printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
2066 pci_resource_len(pdev, 1), pdev->slot_name);
2067 goto err_out_res;
2068 }
2069
2070 /* remap CSR registers */
2071 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2072 if (!regs) {
2073 rc = -EIO;
2074 printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
2075 pci_resource_len(pdev, 1), pciaddr, pdev->slot_name);
2076 goto err_out_res;
2077 }
2078 dev->base_addr = (unsigned long) regs;
2079 de->regs = regs;
2080
2081 de_adapter_wake(de);
2082
2083 /* make sure hardware is not running */
2084 rc = de_reset_mac(de);
2085 if (rc) {
2086 printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
2087 pdev->slot_name);
2088 goto err_out_iomap;
2089 }
2090
2091 /* get MAC address, initialize default media type and
2092 * get list of supported media
2093 */
2094 if (de->de21040) {
2095 de21040_get_mac_address(de);
2096 de21040_get_media_info(de);
2097 } else {
2098 de21041_get_srom_info(de);
2099 }
2100
2101 /* register new network interface with kernel */
2102 rc = register_netdev(dev);
2103 if (rc)
2104 goto err_out_iomap;
2105
2106 /* print info about board and interface just registered */
2107 printk (KERN_INFO "%s: %s at 0x%lx, "
2108 "%02x:%02x:%02x:%02x:%02x:%02x, "
2109 "IRQ %d\n",
2110 dev->name,
2111 de->de21040 ? "21040" : "21041",
2112 dev->base_addr,
2113 dev->dev_addr[0], dev->dev_addr[1],
2114 dev->dev_addr[2], dev->dev_addr[3],
2115 dev->dev_addr[4], dev->dev_addr[5],
2116 dev->irq);
2117
2118 pci_set_drvdata(pdev, dev);
2119
2120 /* enable busmastering */
2121 pci_set_master(pdev);
2122
2123 /* put adapter to sleep */
2124 de_adapter_sleep(de);
2125
2126 return 0;
2127
2128 err_out_iomap:
2129 if (de->ee_data)
2130 kfree(de->ee_data);
2131 iounmap(regs);
2132 err_out_res:
2133 pci_release_regions(pdev);
2134 err_out_disable:
2135 pci_disable_device(pdev);
2136 err_out_free:
2137 kfree(dev);
2138 return rc;
2139 }
2140
2141 static void __exit de_remove_one (struct pci_dev *pdev)
2142 {
2143 struct net_device *dev = pci_get_drvdata(pdev);
2144 struct de_private *de = dev->priv;
2145
2146 if (!dev)
2147 BUG();
2148 unregister_netdev(dev);
2149 if (de->ee_data)
2150 kfree(de->ee_data);
2151 iounmap(de->regs);
2152 pci_release_regions(pdev);
2153 pci_disable_device(pdev);
2154 pci_set_drvdata(pdev, NULL);
2155 kfree(dev);
2156 }
2157
2158 #ifdef CONFIG_PM
2159
2160 static int de_suspend (struct pci_dev *pdev, u32 state)
2161 {
2162 struct net_device *dev = pci_get_drvdata (pdev);
2163 struct de_private *de = dev->priv;
2164
2165 rtnl_lock();
2166 if (netif_running (dev)) {
2167 del_timer_sync(&de->media_timer);
2168
2169 disable_irq(dev->irq);
2170 spin_lock_irq(&de->lock);
2171
2172 de_stop_hw(de);
2173 netif_stop_queue(dev);
2174 netif_device_detach(dev);
2175 netif_carrier_off(dev);
2176
2177 spin_unlock_irq(&de->lock);
2178 enable_irq(dev->irq);
2179
2180 /* Update the error counts. */
2181 __de_get_stats(de);
2182
2183 synchronize_irq(dev->irq);
2184 de_clean_rings(de);
2185
2186 de_adapter_sleep(de);
2187 pci_disable_device(pdev);
2188 } else {
2189 netif_device_detach(dev);
2190 }
2191 rtnl_unlock();
2192 return 0;
2193 }
2194
2195 static int de_resume (struct pci_dev *pdev)
2196 {
2197 struct net_device *dev = pci_get_drvdata (pdev);
2198 struct de_private *de = dev->priv;
2199
2200 rtnl_lock();
2201 if (netif_device_present(dev))
2202 goto out;
2203 if (netif_running(dev)) {
2204 pci_enable_device(pdev);
2205 de_init_hw(de);
2206 netif_device_attach(dev);
2207 } else {
2208 netif_device_attach(dev);
2209 }
2210 out:
2211 rtnl_unlock();
2212 return 0;
2213 }
2214
2215 #endif /* CONFIG_PM */
2216
2217 static struct pci_driver de_driver = {
2218 .name = DRV_NAME,
2219 .id_table = de_pci_tbl,
2220 .probe = de_init_one,
2221 .remove = __exit_p(de_remove_one),
2222 #ifdef CONFIG_PM
2223 .suspend = de_suspend,
2224 .resume = de_resume,
2225 #endif
2226 };
2227
2228 static int __init de_init (void)
2229 {
2230 #ifdef MODULE
2231 printk("%s", version);
2232 #endif
2233 return pci_module_init (&de_driver);
2234 }
2235
2236 static void __exit de_exit (void)
2237 {
2238 pci_unregister_driver (&de_driver);
2239 }
2240
2241 module_init(de_init);
2242 module_exit(de_exit);
Mirror of the linux-mips.org kernel tree