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