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