blob: c78a50586c1d86a0fffa9a59ab461a1996da8122 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090045#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#include <asm/io.h>
48#include <asm/irq.h>
49#include <asm/uaccess.h>
50#include <asm/unaligned.h>
51
52/* These identify the driver base version and may not be removed. */
53static char version[] =
54KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
55
56MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
57MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
58MODULE_LICENSE("GPL");
59MODULE_VERSION(DRV_VERSION);
60
61static int debug = -1;
62module_param (debug, int, 0);
63MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
64
65/* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
Joe Perches8e95a202009-12-03 07:58:21 +000066#if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \
67 defined(CONFIG_SPARC) || defined(__ia64__) || \
68 defined(__sh__) || defined(__mips__)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static int rx_copybreak = 1518;
70#else
71static int rx_copybreak = 100;
72#endif
73module_param (rx_copybreak, int, 0);
74MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
75
76#define PFX DRV_NAME ": "
77
78#define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
79 NETIF_MSG_PROBE | \
80 NETIF_MSG_LINK | \
81 NETIF_MSG_IFDOWN | \
82 NETIF_MSG_IFUP | \
83 NETIF_MSG_RX_ERR | \
84 NETIF_MSG_TX_ERR)
85
Risto Suominenb77e5222009-06-10 09:55:00 +000086/* Descriptor skip length in 32 bit longwords. */
87#ifndef CONFIG_DE2104X_DSL
88#define DSL 0
89#else
90#define DSL CONFIG_DE2104X_DSL
91#endif
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093#define DE_RX_RING_SIZE 64
94#define DE_TX_RING_SIZE 64
95#define DE_RING_BYTES \
96 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
97 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
98#define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
99#define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
100#define TX_BUFFS_AVAIL(CP) \
101 (((CP)->tx_tail <= (CP)->tx_head) ? \
102 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
103 (CP)->tx_tail - (CP)->tx_head - 1)
104
105#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
106#define RX_OFFSET 2
107
108#define DE_SETUP_SKB ((struct sk_buff *) 1)
109#define DE_DUMMY_SKB ((struct sk_buff *) 2)
110#define DE_SETUP_FRAME_WORDS 96
111#define DE_EEPROM_WORDS 256
112#define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
113#define DE_MAX_MEDIA 5
114
115#define DE_MEDIA_TP_AUTO 0
116#define DE_MEDIA_BNC 1
117#define DE_MEDIA_AUI 2
118#define DE_MEDIA_TP 3
119#define DE_MEDIA_TP_FD 4
120#define DE_MEDIA_INVALID DE_MAX_MEDIA
121#define DE_MEDIA_FIRST 0
122#define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
123#define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
124
125#define DE_TIMER_LINK (60 * HZ)
126#define DE_TIMER_NO_LINK (5 * HZ)
127
128#define DE_NUM_REGS 16
129#define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
130#define DE_REGS_VER 1
131
132/* Time in jiffies before concluding the transmitter is hung. */
133#define TX_TIMEOUT (6*HZ)
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135/* This is a mysterious value that can be written to CSR11 in the 21040 (only)
136 to support a pre-NWay full-duplex signaling mechanism using short frames.
137 No one knows what it should be, but if left at its default value some
138 10base2(!) packets trigger a full-duplex-request interrupt. */
139#define FULL_DUPLEX_MAGIC 0x6969
140
141enum {
142 /* NIC registers */
143 BusMode = 0x00,
144 TxPoll = 0x08,
145 RxPoll = 0x10,
146 RxRingAddr = 0x18,
147 TxRingAddr = 0x20,
148 MacStatus = 0x28,
149 MacMode = 0x30,
150 IntrMask = 0x38,
151 RxMissed = 0x40,
152 ROMCmd = 0x48,
153 CSR11 = 0x58,
154 SIAStatus = 0x60,
155 CSR13 = 0x68,
156 CSR14 = 0x70,
157 CSR15 = 0x78,
158 PCIPM = 0x40,
159
160 /* BusMode bits */
161 CmdReset = (1 << 0),
162 CacheAlign16 = 0x00008000,
163 BurstLen4 = 0x00000400,
Risto Suominenb77e5222009-06-10 09:55:00 +0000164 DescSkipLen = (DSL << 2),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 /* Rx/TxPoll bits */
167 NormalTxPoll = (1 << 0),
168 NormalRxPoll = (1 << 0),
169
170 /* Tx/Rx descriptor status bits */
171 DescOwn = (1 << 31),
172 RxError = (1 << 15),
173 RxErrLong = (1 << 7),
174 RxErrCRC = (1 << 1),
175 RxErrFIFO = (1 << 0),
176 RxErrRunt = (1 << 11),
177 RxErrFrame = (1 << 14),
178 RingEnd = (1 << 25),
179 FirstFrag = (1 << 29),
180 LastFrag = (1 << 30),
181 TxError = (1 << 15),
182 TxFIFOUnder = (1 << 1),
183 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
184 TxMaxCol = (1 << 8),
185 TxOWC = (1 << 9),
186 TxJabber = (1 << 14),
187 SetupFrame = (1 << 27),
188 TxSwInt = (1 << 31),
189
190 /* MacStatus bits */
191 IntrOK = (1 << 16),
192 IntrErr = (1 << 15),
193 RxIntr = (1 << 6),
194 RxEmpty = (1 << 7),
195 TxIntr = (1 << 0),
196 TxEmpty = (1 << 2),
197 PciErr = (1 << 13),
198 TxState = (1 << 22) | (1 << 21) | (1 << 20),
199 RxState = (1 << 19) | (1 << 18) | (1 << 17),
200 LinkFail = (1 << 12),
201 LinkPass = (1 << 4),
202 RxStopped = (1 << 8),
203 TxStopped = (1 << 1),
204
205 /* MacMode bits */
206 TxEnable = (1 << 13),
207 RxEnable = (1 << 1),
208 RxTx = TxEnable | RxEnable,
209 FullDuplex = (1 << 9),
210 AcceptAllMulticast = (1 << 7),
211 AcceptAllPhys = (1 << 6),
212 BOCnt = (1 << 5),
213 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
214 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
215
216 /* ROMCmd bits */
217 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
218 EE_CS = 0x01, /* EEPROM chip select. */
219 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
220 EE_WRITE_0 = 0x01,
221 EE_WRITE_1 = 0x05,
222 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
223 EE_ENB = (0x4800 | EE_CS),
224
225 /* The EEPROM commands include the alway-set leading bit. */
226 EE_READ_CMD = 6,
227
228 /* RxMissed bits */
229 RxMissedOver = (1 << 16),
230 RxMissedMask = 0xffff,
231
232 /* SROM-related bits */
233 SROMC0InfoLeaf = 27,
234 MediaBlockMask = 0x3f,
235 MediaCustomCSRs = (1 << 6),
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 /* PCIPM bits */
238 PM_Sleep = (1 << 31),
239 PM_Snooze = (1 << 30),
240 PM_Mask = PM_Sleep | PM_Snooze,
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 /* SIAStatus bits */
243 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
244 NWayRestart = (1 << 12),
245 NonselPortActive = (1 << 9),
Ondrej Zaryca9a7832010-09-25 10:39:17 +0000246 SelPortActive = (1 << 8),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 LinkFailStatus = (1 << 2),
248 NetCxnErr = (1 << 1),
249};
250
251static const u32 de_intr_mask =
252 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
253 LinkPass | LinkFail | PciErr;
254
255/*
256 * Set the programmable burst length to 4 longwords for all:
257 * DMA errors result without these values. Cache align 16 long.
258 */
Risto Suominenb77e5222009-06-10 09:55:00 +0000259static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261struct de_srom_media_block {
262 u8 opts;
263 u16 csr13;
264 u16 csr14;
265 u16 csr15;
Eric Dumazetba2d3582010-06-02 18:10:09 +0000266} __packed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268struct de_srom_info_leaf {
269 u16 default_media;
270 u8 n_blocks;
271 u8 unused;
Eric Dumazetba2d3582010-06-02 18:10:09 +0000272} __packed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274struct de_desc {
Al Viroc559a5b2007-08-23 00:43:22 -0400275 __le32 opts1;
276 __le32 opts2;
277 __le32 addr1;
278 __le32 addr2;
Risto Suominenb77e5222009-06-10 09:55:00 +0000279#if DSL
280 __le32 skip[DSL];
281#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282};
283
284struct media_info {
285 u16 type; /* DE_MEDIA_xxx */
286 u16 csr13;
287 u16 csr14;
288 u16 csr15;
289};
290
291struct ring_info {
292 struct sk_buff *skb;
293 dma_addr_t mapping;
294};
295
296struct de_private {
297 unsigned tx_head;
298 unsigned tx_tail;
299 unsigned rx_tail;
300
301 void __iomem *regs;
302 struct net_device *dev;
303 spinlock_t lock;
304
305 struct de_desc *rx_ring;
306 struct de_desc *tx_ring;
307 struct ring_info tx_skb[DE_TX_RING_SIZE];
308 struct ring_info rx_skb[DE_RX_RING_SIZE];
309 unsigned rx_buf_sz;
310 dma_addr_t ring_dma;
311
312 u32 msg_enable;
313
314 struct net_device_stats net_stats;
315
316 struct pci_dev *pdev;
317
318 u16 setup_frame[DE_SETUP_FRAME_WORDS];
319
320 u32 media_type;
321 u32 media_supported;
322 u32 media_advertise;
323 struct media_info media[DE_MAX_MEDIA];
324 struct timer_list media_timer;
325
326 u8 *ee_data;
327 unsigned board_idx;
328 unsigned de21040 : 1;
329 unsigned media_lock : 1;
330};
331
332
333static void de_set_rx_mode (struct net_device *dev);
334static void de_tx (struct de_private *de);
335static void de_clean_rings (struct de_private *de);
336static void de_media_interrupt (struct de_private *de, u32 status);
337static void de21040_media_timer (unsigned long data);
338static void de21041_media_timer (unsigned long data);
339static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
340
341
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000342static DEFINE_PCI_DEVICE_TABLE(de_pci_tbl) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
344 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
345 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
346 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
347 { },
348};
349MODULE_DEVICE_TABLE(pci, de_pci_tbl);
350
351static const char * const media_name[DE_MAX_MEDIA] = {
352 "10baseT auto",
353 "BNC",
354 "AUI",
355 "10baseT-HD",
356 "10baseT-FD"
357};
358
359/* 21040 transceiver register settings:
360 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
361static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
362static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
363static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
364
365/* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
366static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
Ondrej Zary387a8562010-09-27 11:41:45 +0000367static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
Ondrej Zarye0f9c4f2010-09-23 10:59:18 +0000368/* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */
Ondrej Zary387a8562010-09-27 11:41:45 +0000369static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
371
372
Morten H. Larsen84cc1532010-06-15 13:24:58 -0400373#define dr32(reg) ioread32(de->regs + (reg))
374#define dw32(reg, val) iowrite32((val), de->regs + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
376
377static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
378 u32 status, u32 len)
379{
380 if (netif_msg_rx_err (de))
381 printk (KERN_DEBUG
382 "%s: rx err, slot %d status 0x%x len %d\n",
383 de->dev->name, rx_tail, status, len);
384
385 if ((status & 0x38000300) != 0x0300) {
386 /* Ingore earlier buffers. */
387 if ((status & 0xffff) != 0x7fff) {
388 if (netif_msg_rx_err(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000389 dev_warn(&de->dev->dev,
390 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n",
391 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 de->net_stats.rx_length_errors++;
393 }
394 } else if (status & RxError) {
395 /* There was a fatal error. */
396 de->net_stats.rx_errors++; /* end of a packet.*/
397 if (status & 0x0890) de->net_stats.rx_length_errors++;
398 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
399 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
400 }
401}
402
403static void de_rx (struct de_private *de)
404{
405 unsigned rx_tail = de->rx_tail;
406 unsigned rx_work = DE_RX_RING_SIZE;
407 unsigned drop = 0;
408 int rc;
409
Roel Kluin46578a692009-02-02 21:39:02 -0800410 while (--rx_work) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 u32 status, len;
412 dma_addr_t mapping;
413 struct sk_buff *skb, *copy_skb;
414 unsigned copying_skb, buflen;
415
416 skb = de->rx_skb[rx_tail].skb;
Eric Sesterhenn / snakebyte7e0b58f2006-01-26 22:02:43 +0100417 BUG_ON(!skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 rmb();
419 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
420 if (status & DescOwn)
421 break;
422
423 len = ((status >> 16) & 0x7ff) - 4;
424 mapping = de->rx_skb[rx_tail].mapping;
425
426 if (unlikely(drop)) {
427 de->net_stats.rx_dropped++;
428 goto rx_next;
429 }
430
431 if (unlikely((status & 0x38008300) != 0x0300)) {
432 de_rx_err_acct(de, rx_tail, status, len);
433 goto rx_next;
434 }
435
436 copying_skb = (len <= rx_copybreak);
437
438 if (unlikely(netif_msg_rx_status(de)))
439 printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
440 de->dev->name, rx_tail, status, len,
441 copying_skb);
442
443 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
444 copy_skb = dev_alloc_skb (buflen);
445 if (unlikely(!copy_skb)) {
446 de->net_stats.rx_dropped++;
447 drop = 1;
448 rx_work = 100;
449 goto rx_next;
450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
452 if (!copying_skb) {
453 pci_unmap_single(de->pdev, mapping,
454 buflen, PCI_DMA_FROMDEVICE);
455 skb_put(skb, len);
456
457 mapping =
458 de->rx_skb[rx_tail].mapping =
David S. Miller689be432005-06-28 15:25:31 -0700459 pci_map_single(de->pdev, copy_skb->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 buflen, PCI_DMA_FROMDEVICE);
461 de->rx_skb[rx_tail].skb = copy_skb;
462 } else {
463 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
464 skb_reserve(copy_skb, RX_OFFSET);
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -0300465 skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
466 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
468
469 /* We'll reuse the original ring buffer. */
470 skb = copy_skb;
471 }
472
473 skb->protocol = eth_type_trans (skb, de->dev);
474
475 de->net_stats.rx_packets++;
476 de->net_stats.rx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 rc = netif_rx (skb);
478 if (rc == NET_RX_DROP)
479 drop = 1;
480
481rx_next:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 if (rx_tail == (DE_RX_RING_SIZE - 1))
483 de->rx_ring[rx_tail].opts2 =
484 cpu_to_le32(RingEnd | de->rx_buf_sz);
485 else
486 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
487 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
Risto Suominenb991d2b2009-02-08 17:50:34 -0800488 wmb();
489 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 rx_tail = NEXT_RX(rx_tail);
491 }
492
493 if (!rx_work)
Joe Perchesf639dc72010-01-28 20:59:19 +0000494 dev_warn(&de->dev->dev, "rx work limit reached\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496 de->rx_tail = rx_tail;
497}
498
David Howells7d12e782006-10-05 14:55:46 +0100499static irqreturn_t de_interrupt (int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 struct net_device *dev = dev_instance;
Wang Chen8f15ea42008-11-12 23:38:36 -0800502 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 u32 status;
504
505 status = dr32(MacStatus);
506 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
507 return IRQ_NONE;
508
509 if (netif_msg_intr(de))
510 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
Joe Perchesf639dc72010-01-28 20:59:19 +0000511 dev->name, status, dr32(MacMode),
512 de->rx_tail, de->tx_head, de->tx_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 dw32(MacStatus, status);
515
516 if (status & (RxIntr | RxEmpty)) {
517 de_rx(de);
518 if (status & RxEmpty)
519 dw32(RxPoll, NormalRxPoll);
520 }
521
522 spin_lock(&de->lock);
523
524 if (status & (TxIntr | TxEmpty))
525 de_tx(de);
526
527 if (status & (LinkPass | LinkFail))
528 de_media_interrupt(de, status);
529
530 spin_unlock(&de->lock);
531
532 if (status & PciErr) {
533 u16 pci_status;
534
535 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
536 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
Joe Perchesf639dc72010-01-28 20:59:19 +0000537 dev_err(&de->dev->dev,
538 "PCI bus error, status=%08x, PCI status=%04x\n",
539 status, pci_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 }
541
542 return IRQ_HANDLED;
543}
544
545static void de_tx (struct de_private *de)
546{
547 unsigned tx_head = de->tx_head;
548 unsigned tx_tail = de->tx_tail;
549
550 while (tx_tail != tx_head) {
551 struct sk_buff *skb;
552 u32 status;
553
554 rmb();
555 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
556 if (status & DescOwn)
557 break;
558
559 skb = de->tx_skb[tx_tail].skb;
Eric Sesterhenn / snakebyte7e0b58f2006-01-26 22:02:43 +0100560 BUG_ON(!skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (unlikely(skb == DE_DUMMY_SKB))
562 goto next;
563
564 if (unlikely(skb == DE_SETUP_SKB)) {
565 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
566 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
567 goto next;
568 }
569
570 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
571 skb->len, PCI_DMA_TODEVICE);
572
573 if (status & LastFrag) {
574 if (status & TxError) {
575 if (netif_msg_tx_err(de))
576 printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
577 de->dev->name, status);
578 de->net_stats.tx_errors++;
579 if (status & TxOWC)
580 de->net_stats.tx_window_errors++;
581 if (status & TxMaxCol)
582 de->net_stats.tx_aborted_errors++;
583 if (status & TxLinkFail)
584 de->net_stats.tx_carrier_errors++;
585 if (status & TxFIFOUnder)
586 de->net_stats.tx_fifo_errors++;
587 } else {
588 de->net_stats.tx_packets++;
589 de->net_stats.tx_bytes += skb->len;
590 if (netif_msg_tx_done(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000591 printk(KERN_DEBUG "%s: tx done, slot %d\n",
592 de->dev->name, tx_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
594 dev_kfree_skb_irq(skb);
595 }
596
597next:
598 de->tx_skb[tx_tail].skb = NULL;
599
600 tx_tail = NEXT_TX(tx_tail);
601 }
602
603 de->tx_tail = tx_tail;
604
605 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
606 netif_wake_queue(de->dev);
607}
608
Stephen Hemmingerad096462009-08-31 19:50:53 +0000609static netdev_tx_t de_start_xmit (struct sk_buff *skb,
610 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
Wang Chen8f15ea42008-11-12 23:38:36 -0800612 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 unsigned int entry, tx_free;
614 u32 mapping, len, flags = FirstFrag | LastFrag;
615 struct de_desc *txd;
616
617 spin_lock_irq(&de->lock);
618
619 tx_free = TX_BUFFS_AVAIL(de);
620 if (tx_free == 0) {
621 netif_stop_queue(dev);
622 spin_unlock_irq(&de->lock);
Patrick McHardy5b548142009-06-12 06:22:29 +0000623 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 }
625 tx_free--;
626
627 entry = de->tx_head;
628
629 txd = &de->tx_ring[entry];
630
631 len = skb->len;
632 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
633 if (entry == (DE_TX_RING_SIZE - 1))
634 flags |= RingEnd;
635 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
636 flags |= TxSwInt;
637 flags |= len;
638 txd->opts2 = cpu_to_le32(flags);
639 txd->addr1 = cpu_to_le32(mapping);
640
641 de->tx_skb[entry].skb = skb;
642 de->tx_skb[entry].mapping = mapping;
643 wmb();
644
645 txd->opts1 = cpu_to_le32(DescOwn);
646 wmb();
647
648 de->tx_head = NEXT_TX(entry);
649 if (netif_msg_tx_queued(de))
650 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
651 dev->name, entry, skb->len);
652
653 if (tx_free == 0)
654 netif_stop_queue(dev);
655
656 spin_unlock_irq(&de->lock);
657
658 /* Trigger an immediate transmit demand. */
659 dw32(TxPoll, NormalTxPoll);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Patrick McHardy6ed10652009-06-23 06:03:08 +0000661 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
664/* Set or clear the multicast filter for this adaptor.
665 Note that we only use exclusion around actually queueing the
666 new frame, not around filling de->setup_frame. This is non-deterministic
667 when re-entered but still correct. */
668
669#undef set_bit_le
670#define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
671
672static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
673{
Wang Chen8f15ea42008-11-12 23:38:36 -0800674 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 u16 hash_table[32];
Jiri Pirko22bedad2010-04-01 21:22:57 +0000676 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 int i;
678 u16 *eaddrs;
679
680 memset(hash_table, 0, sizeof(hash_table));
681 set_bit_le(255, hash_table); /* Broadcast entry */
682 /* This should work on big-endian machines as well. */
Jiri Pirko22bedad2010-04-01 21:22:57 +0000683 netdev_for_each_mc_addr(ha, dev) {
684 int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
686 set_bit_le(index, hash_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
688
Jiri Pirko4302b672010-02-18 03:34:54 +0000689 for (i = 0; i < 32; i++) {
690 *setup_frm++ = hash_table[i];
691 *setup_frm++ = hash_table[i];
692 }
693 setup_frm = &de->setup_frame[13*6];
694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 /* Fill the final entry with our physical address. */
696 eaddrs = (u16 *)dev->dev_addr;
697 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
698 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
699 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
700}
701
702static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
703{
Wang Chen8f15ea42008-11-12 23:38:36 -0800704 struct de_private *de = netdev_priv(dev);
Jiri Pirko22bedad2010-04-01 21:22:57 +0000705 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 u16 *eaddrs;
707
708 /* We have <= 14 addresses so we can use the wonderful
709 16 address perfect filtering of the Tulip. */
Jiri Pirko22bedad2010-04-01 21:22:57 +0000710 netdev_for_each_mc_addr(ha, dev) {
711 eaddrs = (u16 *) ha->addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
713 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
714 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
715 }
716 /* Fill the unused entries with the broadcast address. */
Jiri Pirko4302b672010-02-18 03:34:54 +0000717 memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 setup_frm = &de->setup_frame[15*6];
719
720 /* Fill the final entry with our physical address. */
721 eaddrs = (u16 *)dev->dev_addr;
722 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
723 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
724 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
725}
726
727
728static void __de_set_rx_mode (struct net_device *dev)
729{
Wang Chen8f15ea42008-11-12 23:38:36 -0800730 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 u32 macmode;
732 unsigned int entry;
733 u32 mapping;
734 struct de_desc *txd;
735 struct de_desc *dummy_txd = NULL;
736
737 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
738
739 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
740 macmode |= AcceptAllMulticast | AcceptAllPhys;
741 goto out;
742 }
743
Jiri Pirko4cd24ea2010-02-08 04:30:35 +0000744 if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 /* Too many to filter well -- accept all multicasts. */
746 macmode |= AcceptAllMulticast;
747 goto out;
748 }
749
750 /* Note that only the low-address shortword of setup_frame is valid!
751 The values are doubled for big-endian architectures. */
Jiri Pirko4cd24ea2010-02-08 04:30:35 +0000752 if (netdev_mc_count(dev) > 14) /* Must use a multicast hash table. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 build_setup_frame_hash (de->setup_frame, dev);
754 else
755 build_setup_frame_perfect (de->setup_frame, dev);
756
757 /*
758 * Now add this frame to the Tx list.
759 */
760
761 entry = de->tx_head;
762
763 /* Avoid a chip errata by prefixing a dummy entry. */
764 if (entry != 0) {
765 de->tx_skb[entry].skb = DE_DUMMY_SKB;
766
767 dummy_txd = &de->tx_ring[entry];
768 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
769 cpu_to_le32(RingEnd) : 0;
770 dummy_txd->addr1 = 0;
771
772 /* Must set DescOwned later to avoid race with chip */
773
774 entry = NEXT_TX(entry);
775 }
776
777 de->tx_skb[entry].skb = DE_SETUP_SKB;
778 de->tx_skb[entry].mapping = mapping =
779 pci_map_single (de->pdev, de->setup_frame,
780 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
781
782 /* Put the setup frame on the Tx list. */
783 txd = &de->tx_ring[entry];
784 if (entry == (DE_TX_RING_SIZE - 1))
785 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
786 else
787 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
788 txd->addr1 = cpu_to_le32(mapping);
789 wmb();
790
791 txd->opts1 = cpu_to_le32(DescOwn);
792 wmb();
793
794 if (dummy_txd) {
795 dummy_txd->opts1 = cpu_to_le32(DescOwn);
796 wmb();
797 }
798
799 de->tx_head = NEXT_TX(entry);
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 if (TX_BUFFS_AVAIL(de) == 0)
802 netif_stop_queue(dev);
803
804 /* Trigger an immediate transmit demand. */
805 dw32(TxPoll, NormalTxPoll);
806
807out:
808 if (macmode != dr32(MacMode))
809 dw32(MacMode, macmode);
810}
811
812static void de_set_rx_mode (struct net_device *dev)
813{
814 unsigned long flags;
Wang Chen8f15ea42008-11-12 23:38:36 -0800815 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 spin_lock_irqsave (&de->lock, flags);
818 __de_set_rx_mode(dev);
819 spin_unlock_irqrestore (&de->lock, flags);
820}
821
822static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
823{
824 if (unlikely(rx_missed & RxMissedOver))
825 de->net_stats.rx_missed_errors += RxMissedMask;
826 else
827 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
828}
829
830static void __de_get_stats(struct de_private *de)
831{
832 u32 tmp = dr32(RxMissed); /* self-clearing */
833
834 de_rx_missed(de, tmp);
835}
836
837static struct net_device_stats *de_get_stats(struct net_device *dev)
838{
Wang Chen8f15ea42008-11-12 23:38:36 -0800839 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 /* The chip only need report frame silently dropped. */
842 spin_lock_irq(&de->lock);
843 if (netif_running(dev) && netif_device_present(dev))
844 __de_get_stats(de);
845 spin_unlock_irq(&de->lock);
846
847 return &de->net_stats;
848}
849
850static inline int de_is_running (struct de_private *de)
851{
852 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
853}
854
855static void de_stop_rxtx (struct de_private *de)
856{
857 u32 macmode;
Grant Grundler69cac982008-03-08 18:33:16 -0700858 unsigned int i = 1300/100;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 macmode = dr32(MacMode);
861 if (macmode & RxTx) {
862 dw32(MacMode, macmode & ~RxTx);
863 dr32(MacMode);
864 }
865
Grant Grundler69cac982008-03-08 18:33:16 -0700866 /* wait until in-flight frame completes.
867 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
868 * Typically expect this loop to end in < 50 us on 100BT.
869 */
870 while (--i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 if (!de_is_running(de))
872 return;
Grant Grundler69cac982008-03-08 18:33:16 -0700873 udelay(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400875
Joe Perchesf639dc72010-01-28 20:59:19 +0000876 dev_warn(&de->dev->dev, "timeout expired stopping DMA\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
879static inline void de_start_rxtx (struct de_private *de)
880{
881 u32 macmode;
882
883 macmode = dr32(MacMode);
884 if ((macmode & RxTx) != RxTx) {
885 dw32(MacMode, macmode | RxTx);
886 dr32(MacMode);
887 }
888}
889
890static void de_stop_hw (struct de_private *de)
891{
892
893 udelay(5);
894 dw32(IntrMask, 0);
895
896 de_stop_rxtx(de);
897
898 dw32(MacStatus, dr32(MacStatus));
899
900 udelay(10);
901
902 de->rx_tail = 0;
903 de->tx_head = de->tx_tail = 0;
904}
905
906static void de_link_up(struct de_private *de)
907{
908 if (!netif_carrier_ok(de->dev)) {
909 netif_carrier_on(de->dev);
910 if (netif_msg_link(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000911 dev_info(&de->dev->dev, "link up, media %s\n",
912 media_name[de->media_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914}
915
916static void de_link_down(struct de_private *de)
917{
918 if (netif_carrier_ok(de->dev)) {
919 netif_carrier_off(de->dev);
920 if (netif_msg_link(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000921 dev_info(&de->dev->dev, "link down\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 }
923}
924
925static void de_set_media (struct de_private *de)
926{
927 unsigned media = de->media_type;
928 u32 macmode = dr32(MacMode);
929
Ondrej Zaryf25f0f82008-02-25 18:45:46 +0100930 if (de_is_running(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000931 dev_warn(&de->dev->dev,
932 "chip is running while changing media!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
934 if (de->de21040)
935 dw32(CSR11, FULL_DUPLEX_MAGIC);
936 dw32(CSR13, 0); /* Reset phy */
937 dw32(CSR14, de->media[media].csr14);
938 dw32(CSR15, de->media[media].csr15);
939 dw32(CSR13, de->media[media].csr13);
940
941 /* must delay 10ms before writing to other registers,
942 * especially CSR6
943 */
944 mdelay(10);
945
946 if (media == DE_MEDIA_TP_FD)
947 macmode |= FullDuplex;
948 else
949 macmode &= ~FullDuplex;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400950
Ondrej Zary862ea4f2010-09-28 08:18:55 +0000951 if (netif_msg_link(de))
Joe Perchesf639dc72010-01-28 20:59:19 +0000952 dev_info(&de->dev->dev, "set link %s\n", media_name[media]);
Ondrej Zary862ea4f2010-09-28 08:18:55 +0000953 if (netif_msg_hw(de)) {
Joe Perchesf639dc72010-01-28 20:59:19 +0000954 dev_info(&de->dev->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
955 dr32(MacMode), dr32(SIAStatus),
956 dr32(CSR13), dr32(CSR14), dr32(CSR15));
957
958 dev_info(&de->dev->dev,
959 "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
960 macmode, de->media[media].csr13,
961 de->media[media].csr14, de->media[media].csr15);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
963 if (macmode != dr32(MacMode))
964 dw32(MacMode, macmode);
965}
966
967static void de_next_media (struct de_private *de, u32 *media,
968 unsigned int n_media)
969{
970 unsigned int i;
971
972 for (i = 0; i < n_media; i++) {
973 if (de_ok_to_advertise(de, media[i])) {
974 de->media_type = media[i];
975 return;
976 }
977 }
978}
979
980static void de21040_media_timer (unsigned long data)
981{
982 struct de_private *de = (struct de_private *) data;
983 struct net_device *dev = de->dev;
984 u32 status = dr32(SIAStatus);
985 unsigned int carrier;
986 unsigned long flags;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 carrier = (status & NetCxnErr) ? 0 : 1;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 if (carrier) {
991 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
992 goto no_link_yet;
993
994 de->media_timer.expires = jiffies + DE_TIMER_LINK;
995 add_timer(&de->media_timer);
996 if (!netif_carrier_ok(dev))
997 de_link_up(de);
998 else
999 if (netif_msg_timer(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001000 dev_info(&dev->dev, "%s link ok, status %x\n",
1001 media_name[de->media_type], status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 return;
1003 }
1004
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001005 de_link_down(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006
1007 if (de->media_lock)
1008 return;
1009
1010 if (de->media_type == DE_MEDIA_AUI) {
1011 u32 next_state = DE_MEDIA_TP;
1012 de_next_media(de, &next_state, 1);
1013 } else {
1014 u32 next_state = DE_MEDIA_AUI;
1015 de_next_media(de, &next_state, 1);
1016 }
1017
1018 spin_lock_irqsave(&de->lock, flags);
1019 de_stop_rxtx(de);
1020 spin_unlock_irqrestore(&de->lock, flags);
1021 de_set_media(de);
1022 de_start_rxtx(de);
1023
1024no_link_yet:
1025 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1026 add_timer(&de->media_timer);
1027
1028 if (netif_msg_timer(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001029 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1030 media_name[de->media_type], status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031}
1032
1033static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1034{
1035 switch (new_media) {
1036 case DE_MEDIA_TP_AUTO:
1037 if (!(de->media_advertise & ADVERTISED_Autoneg))
1038 return 0;
1039 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1040 return 0;
1041 break;
1042 case DE_MEDIA_BNC:
1043 if (!(de->media_advertise & ADVERTISED_BNC))
1044 return 0;
1045 break;
1046 case DE_MEDIA_AUI:
1047 if (!(de->media_advertise & ADVERTISED_AUI))
1048 return 0;
1049 break;
1050 case DE_MEDIA_TP:
1051 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1052 return 0;
1053 break;
1054 case DE_MEDIA_TP_FD:
1055 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1056 return 0;
1057 break;
1058 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001059
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 return 1;
1061}
1062
1063static void de21041_media_timer (unsigned long data)
1064{
1065 struct de_private *de = (struct de_private *) data;
1066 struct net_device *dev = de->dev;
1067 u32 status = dr32(SIAStatus);
1068 unsigned int carrier;
1069 unsigned long flags;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001070
Ondrej Zaryca9a7832010-09-25 10:39:17 +00001071 /* clear port active bits */
1072 dw32(SIAStatus, NonselPortActive | SelPortActive);
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 carrier = (status & NetCxnErr) ? 0 : 1;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 if (carrier) {
1077 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1078 de->media_type == DE_MEDIA_TP ||
1079 de->media_type == DE_MEDIA_TP_FD) &&
1080 (status & LinkFailStatus))
1081 goto no_link_yet;
1082
1083 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1084 add_timer(&de->media_timer);
1085 if (!netif_carrier_ok(dev))
1086 de_link_up(de);
1087 else
1088 if (netif_msg_timer(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001089 dev_info(&dev->dev,
1090 "%s link ok, mode %x status %x\n",
1091 media_name[de->media_type],
1092 dr32(MacMode), status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 return;
1094 }
1095
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001096 de_link_down(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
1098 /* if media type locked, don't switch media */
1099 if (de->media_lock)
1100 goto set_media;
1101
1102 /* if activity detected, use that as hint for new media type */
1103 if (status & NonselPortActive) {
1104 unsigned int have_media = 1;
1105
1106 /* if AUI/BNC selected, then activity is on TP port */
1107 if (de->media_type == DE_MEDIA_AUI ||
1108 de->media_type == DE_MEDIA_BNC) {
1109 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1110 de->media_type = DE_MEDIA_TP_AUTO;
1111 else
1112 have_media = 0;
1113 }
1114
1115 /* TP selected. If there is only TP and BNC, then it's BNC */
1116 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1117 de_ok_to_advertise(de, DE_MEDIA_BNC))
1118 de->media_type = DE_MEDIA_BNC;
1119
1120 /* TP selected. If there is only TP and AUI, then it's AUI */
1121 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1122 de_ok_to_advertise(de, DE_MEDIA_AUI))
1123 de->media_type = DE_MEDIA_AUI;
1124
1125 /* otherwise, ignore the hint */
1126 else
1127 have_media = 0;
1128
1129 if (have_media)
1130 goto set_media;
1131 }
1132
1133 /*
1134 * Absent or ambiguous activity hint, move to next advertised
1135 * media state. If de->media_type is left unchanged, this
1136 * simply resets the PHY and reloads the current media settings.
1137 */
1138 if (de->media_type == DE_MEDIA_AUI) {
1139 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1140 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1141 } else if (de->media_type == DE_MEDIA_BNC) {
1142 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1143 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1144 } else {
1145 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1146 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1147 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001148
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149set_media:
1150 spin_lock_irqsave(&de->lock, flags);
1151 de_stop_rxtx(de);
1152 spin_unlock_irqrestore(&de->lock, flags);
1153 de_set_media(de);
1154 de_start_rxtx(de);
1155
1156no_link_yet:
1157 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1158 add_timer(&de->media_timer);
1159
1160 if (netif_msg_timer(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001161 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1162 media_name[de->media_type], status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163}
1164
1165static void de_media_interrupt (struct de_private *de, u32 status)
1166{
1167 if (status & LinkPass) {
Ondrej Zaryca9a7832010-09-25 10:39:17 +00001168 /* Ignore if current media is AUI or BNC and we can't use TP */
1169 if ((de->media_type == DE_MEDIA_AUI ||
1170 de->media_type == DE_MEDIA_BNC) &&
1171 (de->media_lock ||
1172 !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)))
1173 return;
1174 /* If current media is not TP, change it to TP */
1175 if ((de->media_type == DE_MEDIA_AUI ||
1176 de->media_type == DE_MEDIA_BNC)) {
1177 de->media_type = DE_MEDIA_TP_AUTO;
1178 de_stop_rxtx(de);
1179 de_set_media(de);
1180 de_start_rxtx(de);
1181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 de_link_up(de);
1183 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1184 return;
1185 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001186
Eric Sesterhenn / snakebyte7e0b58f2006-01-26 22:02:43 +01001187 BUG_ON(!(status & LinkFail));
Ondrej Zaryca9a7832010-09-25 10:39:17 +00001188 /* Mark the link as down only if current media is TP */
1189 if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI &&
1190 de->media_type != DE_MEDIA_BNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 de_link_down(de);
1192 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1193 }
1194}
1195
1196static int de_reset_mac (struct de_private *de)
1197{
1198 u32 status, tmp;
1199
1200 /*
1201 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1202 * in this area.
1203 */
1204
1205 if (dr32(BusMode) == 0xffffffff)
1206 return -EBUSY;
1207
1208 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1209 dw32 (BusMode, CmdReset);
1210 mdelay (1);
1211
1212 dw32 (BusMode, de_bus_mode);
1213 mdelay (1);
1214
1215 for (tmp = 0; tmp < 5; tmp++) {
1216 dr32 (BusMode);
1217 mdelay (1);
1218 }
1219
1220 mdelay (1);
1221
1222 status = dr32(MacStatus);
1223 if (status & (RxState | TxState))
1224 return -EBUSY;
1225 if (status == 0xffffffff)
1226 return -ENODEV;
1227 return 0;
1228}
1229
1230static void de_adapter_wake (struct de_private *de)
1231{
1232 u32 pmctl;
1233
1234 if (de->de21040)
1235 return;
1236
1237 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1238 if (pmctl & PM_Mask) {
1239 pmctl &= ~PM_Mask;
1240 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1241
1242 /* de4x5.c delays, so we do too */
1243 msleep(10);
1244 }
1245}
1246
1247static void de_adapter_sleep (struct de_private *de)
1248{
1249 u32 pmctl;
1250
1251 if (de->de21040)
1252 return;
1253
Ondrej Zaryb0255a02010-09-24 23:57:02 +00001254 dw32(CSR13, 0); /* Reset phy */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1256 pmctl |= PM_Sleep;
1257 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1258}
1259
1260static int de_init_hw (struct de_private *de)
1261{
1262 struct net_device *dev = de->dev;
1263 u32 macmode;
1264 int rc;
1265
1266 de_adapter_wake(de);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 macmode = dr32(MacMode) & ~MacModeClear;
1269
1270 rc = de_reset_mac(de);
1271 if (rc)
1272 return rc;
1273
1274 de_set_media(de); /* reset phy */
1275
1276 dw32(RxRingAddr, de->ring_dma);
1277 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1278
1279 dw32(MacMode, RxTx | macmode);
1280
1281 dr32(RxMissed); /* self-clearing */
1282
1283 dw32(IntrMask, de_intr_mask);
1284
1285 de_set_rx_mode(dev);
1286
1287 return 0;
1288}
1289
1290static int de_refill_rx (struct de_private *de)
1291{
1292 unsigned i;
1293
1294 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1295 struct sk_buff *skb;
1296
1297 skb = dev_alloc_skb(de->rx_buf_sz);
1298 if (!skb)
1299 goto err_out;
1300
1301 skb->dev = de->dev;
1302
1303 de->rx_skb[i].mapping = pci_map_single(de->pdev,
David S. Miller689be432005-06-28 15:25:31 -07001304 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 de->rx_skb[i].skb = skb;
1306
1307 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1308 if (i == (DE_RX_RING_SIZE - 1))
1309 de->rx_ring[i].opts2 =
1310 cpu_to_le32(RingEnd | de->rx_buf_sz);
1311 else
1312 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1313 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1314 de->rx_ring[i].addr2 = 0;
1315 }
1316
1317 return 0;
1318
1319err_out:
1320 de_clean_rings(de);
1321 return -ENOMEM;
1322}
1323
1324static int de_init_rings (struct de_private *de)
1325{
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
1329 de->rx_tail = 0;
1330 de->tx_head = de->tx_tail = 0;
1331
1332 return de_refill_rx (de);
1333}
1334
1335static int de_alloc_rings (struct de_private *de)
1336{
1337 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1338 if (!de->rx_ring)
1339 return -ENOMEM;
1340 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1341 return de_init_rings(de);
1342}
1343
1344static void de_clean_rings (struct de_private *de)
1345{
1346 unsigned i;
1347
1348 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1349 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1350 wmb();
1351 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1352 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1353 wmb();
1354
1355 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1356 if (de->rx_skb[i].skb) {
1357 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1358 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1359 dev_kfree_skb(de->rx_skb[i].skb);
1360 }
1361 }
1362
1363 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1364 struct sk_buff *skb = de->tx_skb[i].skb;
1365 if ((skb) && (skb != DE_DUMMY_SKB)) {
1366 if (skb != DE_SETUP_SKB) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 de->net_stats.tx_dropped++;
1368 pci_unmap_single(de->pdev,
1369 de->tx_skb[i].mapping,
1370 skb->len, PCI_DMA_TODEVICE);
Eric Sesterhenn5185c7c2006-03-22 22:30:34 +01001371 dev_kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 } else {
1373 pci_unmap_single(de->pdev,
1374 de->tx_skb[i].mapping,
1375 sizeof(de->setup_frame),
1376 PCI_DMA_TODEVICE);
1377 }
1378 }
1379 }
1380
1381 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1382 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1383}
1384
1385static void de_free_rings (struct de_private *de)
1386{
1387 de_clean_rings(de);
1388 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1389 de->rx_ring = NULL;
1390 de->tx_ring = NULL;
1391}
1392
1393static int de_open (struct net_device *dev)
1394{
Wang Chen8f15ea42008-11-12 23:38:36 -08001395 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
1398 if (netif_msg_ifup(de))
1399 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1400
1401 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1402
1403 rc = de_alloc_rings(de);
1404 if (rc) {
Joe Perchesf639dc72010-01-28 20:59:19 +00001405 dev_err(&dev->dev, "ring allocation failure, err=%d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 return rc;
1407 }
1408
Francois Romieu3f735b72006-03-08 22:41:15 +01001409 dw32(IntrMask, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001411 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 if (rc) {
Joe Perchesf639dc72010-01-28 20:59:19 +00001413 dev_err(&dev->dev, "IRQ %d request failure, err=%d\n",
1414 dev->irq, rc);
Francois Romieu3f735b72006-03-08 22:41:15 +01001415 goto err_out_free;
1416 }
1417
1418 rc = de_init_hw(de);
1419 if (rc) {
Joe Perchesf639dc72010-01-28 20:59:19 +00001420 dev_err(&dev->dev, "h/w init failure, err=%d\n", rc);
Francois Romieu3f735b72006-03-08 22:41:15 +01001421 goto err_out_free_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 }
1423
1424 netif_start_queue(dev);
1425 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1426
1427 return 0;
1428
Francois Romieu3f735b72006-03-08 22:41:15 +01001429err_out_free_irq:
1430 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431err_out_free:
1432 de_free_rings(de);
1433 return rc;
1434}
1435
1436static int de_close (struct net_device *dev)
1437{
Wang Chen8f15ea42008-11-12 23:38:36 -08001438 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 unsigned long flags;
1440
1441 if (netif_msg_ifdown(de))
1442 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1443
1444 del_timer_sync(&de->media_timer);
1445
1446 spin_lock_irqsave(&de->lock, flags);
1447 de_stop_hw(de);
1448 netif_stop_queue(dev);
1449 netif_carrier_off(dev);
1450 spin_unlock_irqrestore(&de->lock, flags);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 free_irq(dev->irq, dev);
1453
1454 de_free_rings(de);
1455 de_adapter_sleep(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 return 0;
1457}
1458
1459static void de_tx_timeout (struct net_device *dev)
1460{
Wang Chen8f15ea42008-11-12 23:38:36 -08001461 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1464 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1465 de->rx_tail, de->tx_head, de->tx_tail);
1466
1467 del_timer_sync(&de->media_timer);
1468
1469 disable_irq(dev->irq);
1470 spin_lock_irq(&de->lock);
1471
1472 de_stop_hw(de);
1473 netif_stop_queue(dev);
1474 netif_carrier_off(dev);
1475
1476 spin_unlock_irq(&de->lock);
1477 enable_irq(dev->irq);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001478
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 /* Update the error counts. */
1480 __de_get_stats(de);
1481
1482 synchronize_irq(dev->irq);
1483 de_clean_rings(de);
1484
Francois Romieu39bf4292006-03-08 22:45:52 +01001485 de_init_rings(de);
1486
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 de_init_hw(de);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001488
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 netif_wake_queue(dev);
1490}
1491
1492static void __de_get_regs(struct de_private *de, u8 *buf)
1493{
1494 int i;
1495 u32 *rbuf = (u32 *)buf;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001496
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 /* read all CSRs */
1498 for (i = 0; i < DE_NUM_REGS; i++)
1499 rbuf[i] = dr32(i * 8);
1500
1501 /* handle self-clearing RxMissed counter, CSR8 */
1502 de_rx_missed(de, rbuf[8]);
1503}
1504
1505static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1506{
1507 ecmd->supported = de->media_supported;
1508 ecmd->transceiver = XCVR_INTERNAL;
1509 ecmd->phy_address = 0;
1510 ecmd->advertising = de->media_advertise;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 switch (de->media_type) {
1513 case DE_MEDIA_AUI:
1514 ecmd->port = PORT_AUI;
1515 ecmd->speed = 5;
1516 break;
1517 case DE_MEDIA_BNC:
1518 ecmd->port = PORT_BNC;
1519 ecmd->speed = 2;
1520 break;
1521 default:
1522 ecmd->port = PORT_TP;
1523 ecmd->speed = SPEED_10;
1524 break;
1525 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001526
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 if (dr32(MacMode) & FullDuplex)
1528 ecmd->duplex = DUPLEX_FULL;
1529 else
1530 ecmd->duplex = DUPLEX_HALF;
1531
1532 if (de->media_lock)
1533 ecmd->autoneg = AUTONEG_DISABLE;
1534 else
1535 ecmd->autoneg = AUTONEG_ENABLE;
1536
1537 /* ignore maxtxpkt, maxrxpkt for now */
1538
1539 return 0;
1540}
1541
1542static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1543{
1544 u32 new_media;
1545 unsigned int media_lock;
1546
1547 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1548 return -EINVAL;
1549 if (de->de21040 && ecmd->speed == 2)
1550 return -EINVAL;
1551 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1552 return -EINVAL;
1553 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1554 return -EINVAL;
1555 if (de->de21040 && ecmd->port == PORT_BNC)
1556 return -EINVAL;
1557 if (ecmd->transceiver != XCVR_INTERNAL)
1558 return -EINVAL;
1559 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1560 return -EINVAL;
1561 if (ecmd->advertising & ~de->media_supported)
1562 return -EINVAL;
1563 if (ecmd->autoneg == AUTONEG_ENABLE &&
1564 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1565 return -EINVAL;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001566
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 switch (ecmd->port) {
1568 case PORT_AUI:
1569 new_media = DE_MEDIA_AUI;
1570 if (!(ecmd->advertising & ADVERTISED_AUI))
1571 return -EINVAL;
1572 break;
1573 case PORT_BNC:
1574 new_media = DE_MEDIA_BNC;
1575 if (!(ecmd->advertising & ADVERTISED_BNC))
1576 return -EINVAL;
1577 break;
1578 default:
1579 if (ecmd->autoneg == AUTONEG_ENABLE)
1580 new_media = DE_MEDIA_TP_AUTO;
1581 else if (ecmd->duplex == DUPLEX_FULL)
1582 new_media = DE_MEDIA_TP_FD;
1583 else
1584 new_media = DE_MEDIA_TP;
1585 if (!(ecmd->advertising & ADVERTISED_TP))
1586 return -EINVAL;
1587 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1588 return -EINVAL;
1589 break;
1590 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001591
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 if ((new_media == de->media_type) &&
1595 (media_lock == de->media_lock) &&
1596 (ecmd->advertising == de->media_advertise))
1597 return 0; /* nothing to change */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001598
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 de_link_down(de);
Ondrej Zary387a8562010-09-27 11:41:45 +00001600 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 de_stop_rxtx(de);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001602
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 de->media_type = new_media;
1604 de->media_lock = media_lock;
1605 de->media_advertise = ecmd->advertising;
1606 de_set_media(de);
Ondrej Zary387a8562010-09-27 11:41:45 +00001607 if (netif_running(de->dev))
1608 de_start_rxtx(de);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001609
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 return 0;
1611}
1612
1613static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1614{
Wang Chen8f15ea42008-11-12 23:38:36 -08001615 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
1617 strcpy (info->driver, DRV_NAME);
1618 strcpy (info->version, DRV_VERSION);
1619 strcpy (info->bus_info, pci_name(de->pdev));
1620 info->eedump_len = DE_EEPROM_SIZE;
1621}
1622
1623static int de_get_regs_len(struct net_device *dev)
1624{
1625 return DE_REGS_SIZE;
1626}
1627
1628static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1629{
Wang Chen8f15ea42008-11-12 23:38:36 -08001630 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 int rc;
1632
1633 spin_lock_irq(&de->lock);
1634 rc = __de_get_settings(de, ecmd);
1635 spin_unlock_irq(&de->lock);
1636
1637 return rc;
1638}
1639
1640static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1641{
Wang Chen8f15ea42008-11-12 23:38:36 -08001642 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 int rc;
1644
1645 spin_lock_irq(&de->lock);
1646 rc = __de_set_settings(de, ecmd);
1647 spin_unlock_irq(&de->lock);
1648
1649 return rc;
1650}
1651
1652static u32 de_get_msglevel(struct net_device *dev)
1653{
Wang Chen8f15ea42008-11-12 23:38:36 -08001654 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
1656 return de->msg_enable;
1657}
1658
1659static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1660{
Wang Chen8f15ea42008-11-12 23:38:36 -08001661 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
1663 de->msg_enable = msglvl;
1664}
1665
1666static int de_get_eeprom(struct net_device *dev,
1667 struct ethtool_eeprom *eeprom, u8 *data)
1668{
Wang Chen8f15ea42008-11-12 23:38:36 -08001669 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
1671 if (!de->ee_data)
1672 return -EOPNOTSUPP;
1673 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1674 (eeprom->len != DE_EEPROM_SIZE))
1675 return -EINVAL;
1676 memcpy(data, de->ee_data, eeprom->len);
1677
1678 return 0;
1679}
1680
1681static int de_nway_reset(struct net_device *dev)
1682{
Wang Chen8f15ea42008-11-12 23:38:36 -08001683 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 u32 status;
1685
1686 if (de->media_type != DE_MEDIA_TP_AUTO)
1687 return -EINVAL;
1688 if (netif_carrier_ok(de->dev))
1689 de_link_down(de);
1690
1691 status = dr32(SIAStatus);
1692 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1693 if (netif_msg_link(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001694 dev_info(&de->dev->dev, "link nway restart, status %x,%x\n",
1695 status, dr32(SIAStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 return 0;
1697}
1698
1699static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1700 void *data)
1701{
Wang Chen8f15ea42008-11-12 23:38:36 -08001702 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
1704 regs->version = (DE_REGS_VER << 2) | de->de21040;
1705
1706 spin_lock_irq(&de->lock);
1707 __de_get_regs(de, data);
1708 spin_unlock_irq(&de->lock);
1709}
1710
Jeff Garzik7282d492006-09-13 14:30:00 -04001711static const struct ethtool_ops de_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 .get_link = ethtool_op_get_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 .get_drvinfo = de_get_drvinfo,
1714 .get_regs_len = de_get_regs_len,
1715 .get_settings = de_get_settings,
1716 .set_settings = de_set_settings,
1717 .get_msglevel = de_get_msglevel,
1718 .set_msglevel = de_set_msglevel,
1719 .get_eeprom = de_get_eeprom,
1720 .nway_reset = de_nway_reset,
1721 .get_regs = de_get_regs,
1722};
1723
Prarit Bhargava4c44fd02007-03-06 02:42:00 -08001724static void __devinit de21040_get_mac_address (struct de_private *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
1726 unsigned i;
1727
1728 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
Martin Langerbc0da3f2008-10-13 18:49:38 -07001729 udelay(5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
1731 for (i = 0; i < 6; i++) {
1732 int value, boguscnt = 100000;
Hannes Ederec1d1ebb2008-12-26 00:07:45 -08001733 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 value = dr32(ROMCmd);
Morten H. Larsen84cc1532010-06-15 13:24:58 -04001735 rmb();
Hannes Ederec1d1ebb2008-12-26 00:07:45 -08001736 } while (value < 0 && --boguscnt > 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 de->dev->dev_addr[i] = value;
1738 udelay(1);
1739 if (boguscnt <= 0)
Joe Perchesf639dc72010-01-28 20:59:19 +00001740 pr_warning(PFX "timeout reading 21040 MAC address byte %u\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 }
1742}
1743
Prarit Bhargava4c44fd02007-03-06 02:42:00 -08001744static void __devinit de21040_get_media_info(struct de_private *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745{
1746 unsigned int i;
1747
1748 de->media_type = DE_MEDIA_TP;
1749 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1750 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1751 de->media_advertise = de->media_supported;
1752
1753 for (i = 0; i < DE_MAX_MEDIA; i++) {
1754 switch (i) {
1755 case DE_MEDIA_AUI:
1756 case DE_MEDIA_TP:
1757 case DE_MEDIA_TP_FD:
1758 de->media[i].type = i;
1759 de->media[i].csr13 = t21040_csr13[i];
1760 de->media[i].csr14 = t21040_csr14[i];
1761 de->media[i].csr15 = t21040_csr15[i];
1762 break;
1763 default:
1764 de->media[i].type = DE_MEDIA_INVALID;
1765 break;
1766 }
1767 }
1768}
1769
1770/* Note: this routine returns extra data bits for size detection. */
Helge Deller4a1d2d82006-10-06 12:12:34 -06001771static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772{
1773 int i;
1774 unsigned retval = 0;
1775 void __iomem *ee_addr = regs + ROMCmd;
1776 int read_cmd = location | (EE_READ_CMD << addr_len);
1777
1778 writel(EE_ENB & ~EE_CS, ee_addr);
1779 writel(EE_ENB, ee_addr);
1780
1781 /* Shift the read command bits out. */
1782 for (i = 4 + addr_len; i >= 0; i--) {
1783 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1784 writel(EE_ENB | dataval, ee_addr);
1785 readl(ee_addr);
1786 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1787 readl(ee_addr);
1788 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1789 }
1790 writel(EE_ENB, ee_addr);
1791 readl(ee_addr);
1792
1793 for (i = 16; i > 0; i--) {
1794 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1795 readl(ee_addr);
1796 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1797 writel(EE_ENB, ee_addr);
1798 readl(ee_addr);
1799 }
1800
1801 /* Terminate the EEPROM access. */
1802 writel(EE_ENB & ~EE_CS, ee_addr);
1803 return retval;
1804}
1805
Prarit Bhargava4c44fd02007-03-06 02:42:00 -08001806static void __devinit de21041_get_srom_info (struct de_private *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807{
1808 unsigned i, sa_offset = 0, ofs;
1809 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1810 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1811 struct de_srom_info_leaf *il;
1812 void *bufp;
1813
1814 /* download entire eeprom */
1815 for (i = 0; i < DE_EEPROM_WORDS; i++)
Al Viroc559a5b2007-08-23 00:43:22 -04001816 ((__le16 *)ee_data)[i] =
1817 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
1819 /* DEC now has a specification but early board makers
1820 just put the address in the first EEPROM locations. */
1821 /* This does memcmp(eedata, eedata+16, 8) */
Ralf Baechlebc053d42005-10-10 14:50:46 +01001822
1823#ifndef CONFIG_MIPS_COBALT
1824
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 for (i = 0; i < 8; i ++)
1826 if (ee_data[i] != ee_data[16+i])
1827 sa_offset = 20;
1828
Ralf Baechlebc053d42005-10-10 14:50:46 +01001829#endif
1830
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 /* store MAC address */
1832 for (i = 0; i < 6; i ++)
1833 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1834
1835 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1836 ofs = ee_data[SROMC0InfoLeaf];
1837 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1838 goto bad_srom;
1839
1840 /* get pointer to info leaf */
1841 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1842
1843 /* paranoia checks */
1844 if (il->n_blocks == 0)
1845 goto bad_srom;
1846 if ((sizeof(ee_data) - ofs) <
1847 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1848 goto bad_srom;
1849
1850 /* get default media type */
Harvey Harrison445854f2008-05-28 16:51:04 -07001851 switch (get_unaligned(&il->default_media)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1853 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1854 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1855 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1856 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001857
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 if (netif_msg_probe(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001859 pr_info("de%d: SROM leaf offset %u, default media %s\n",
1860 de->board_idx, ofs, media_name[de->media_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 /* init SIA register values to defaults */
1863 for (i = 0; i < DE_MAX_MEDIA; i++) {
1864 de->media[i].type = DE_MEDIA_INVALID;
1865 de->media[i].csr13 = 0xffff;
1866 de->media[i].csr14 = 0xffff;
1867 de->media[i].csr15 = 0xffff;
1868 }
1869
1870 /* parse media blocks to see what medias are supported,
1871 * and if any custom CSR values are provided
1872 */
1873 bufp = ((void *)il) + sizeof(*il);
1874 for (i = 0; i < il->n_blocks; i++) {
1875 struct de_srom_media_block *ib = bufp;
1876 unsigned idx;
1877
1878 /* index based on media type in media block */
1879 switch(ib->opts & MediaBlockMask) {
1880 case 0: /* 10baseT */
1881 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1882 | SUPPORTED_Autoneg;
1883 idx = DE_MEDIA_TP;
1884 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1885 break;
1886 case 1: /* BNC */
1887 de->media_supported |= SUPPORTED_BNC;
1888 idx = DE_MEDIA_BNC;
1889 break;
1890 case 2: /* AUI */
1891 de->media_supported |= SUPPORTED_AUI;
1892 idx = DE_MEDIA_AUI;
1893 break;
1894 case 4: /* 10baseT-FD */
1895 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1896 | SUPPORTED_Autoneg;
1897 idx = DE_MEDIA_TP_FD;
1898 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1899 break;
1900 default:
1901 goto bad_srom;
1902 }
1903
1904 de->media[idx].type = idx;
1905
1906 if (netif_msg_probe(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001907 pr_info("de%d: media block #%u: %s",
1908 de->board_idx, i,
1909 media_name[de->media[idx].type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
1911 bufp += sizeof (ib->opts);
1912
1913 if (ib->opts & MediaCustomCSRs) {
Harvey Harrison445854f2008-05-28 16:51:04 -07001914 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1915 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1916 de->media[idx].csr15 = get_unaligned(&ib->csr15);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1918 sizeof(ib->csr15);
1919
1920 if (netif_msg_probe(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001921 pr_cont(" (%x,%x,%x)\n",
1922 de->media[idx].csr13,
1923 de->media[idx].csr14,
1924 de->media[idx].csr15);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001925
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 } else if (netif_msg_probe(de))
Joe Perchesf639dc72010-01-28 20:59:19 +00001927 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
1929 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1930 break;
1931 }
1932
1933 de->media_advertise = de->media_supported;
1934
1935fill_defaults:
1936 /* fill in defaults, for cases where custom CSRs not used */
1937 for (i = 0; i < DE_MAX_MEDIA; i++) {
1938 if (de->media[i].csr13 == 0xffff)
1939 de->media[i].csr13 = t21041_csr13[i];
Ondrej Zarye0f9c4f2010-09-23 10:59:18 +00001940 if (de->media[i].csr14 == 0xffff) {
1941 /* autonegotiation is broken at least on some chip
1942 revisions - rev. 0x21 works, 0x11 does not */
1943 if (de->pdev->revision < 0x20)
1944 de->media[i].csr14 = t21041_csr14_brk[i];
1945 else
1946 de->media[i].csr14 = t21041_csr14[i];
1947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 if (de->media[i].csr15 == 0xffff)
1949 de->media[i].csr15 = t21041_csr15[i];
1950 }
1951
Eric Sesterhennc3a93922006-10-23 22:20:15 +02001952 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
1954 return;
1955
1956bad_srom:
1957 /* for error cases, it's ok to assume we support all these */
1958 for (i = 0; i < DE_MAX_MEDIA; i++)
1959 de->media[i].type = i;
1960 de->media_supported =
1961 SUPPORTED_10baseT_Half |
1962 SUPPORTED_10baseT_Full |
1963 SUPPORTED_Autoneg |
1964 SUPPORTED_TP |
1965 SUPPORTED_AUI |
1966 SUPPORTED_BNC;
1967 goto fill_defaults;
1968}
1969
Stephen Hemminger90d87432009-01-07 17:59:47 -08001970static const struct net_device_ops de_netdev_ops = {
1971 .ndo_open = de_open,
1972 .ndo_stop = de_close,
1973 .ndo_set_multicast_list = de_set_rx_mode,
1974 .ndo_start_xmit = de_start_xmit,
1975 .ndo_get_stats = de_get_stats,
1976 .ndo_tx_timeout = de_tx_timeout,
1977 .ndo_change_mtu = eth_change_mtu,
1978 .ndo_set_mac_address = eth_mac_addr,
1979 .ndo_validate_addr = eth_validate_addr,
1980};
1981
Helge Deller4a1d2d82006-10-06 12:12:34 -06001982static int __devinit de_init_one (struct pci_dev *pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 const struct pci_device_id *ent)
1984{
1985 struct net_device *dev;
1986 struct de_private *de;
1987 int rc;
1988 void __iomem *regs;
Jeff Garzikafc70972005-08-31 06:11:16 -04001989 unsigned long pciaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 static int board_idx = -1;
1991
1992 board_idx++;
1993
1994#ifndef MODULE
1995 if (board_idx == 0)
1996 printk("%s", version);
1997#endif
1998
1999 /* allocate a new ethernet device structure, and fill in defaults */
2000 dev = alloc_etherdev(sizeof(struct de_private));
2001 if (!dev)
2002 return -ENOMEM;
2003
Stephen Hemminger90d87432009-01-07 17:59:47 -08002004 dev->netdev_ops = &de_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 SET_NETDEV_DEV(dev, &pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 dev->ethtool_ops = &de_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 dev->watchdog_timeo = TX_TIMEOUT;
2008
Wang Chen8f15ea42008-11-12 23:38:36 -08002009 de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 de->de21040 = ent->driver_data == 0 ? 1 : 0;
2011 de->pdev = pdev;
2012 de->dev = dev;
2013 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
2014 de->board_idx = board_idx;
2015 spin_lock_init (&de->lock);
2016 init_timer(&de->media_timer);
2017 if (de->de21040)
2018 de->media_timer.function = de21040_media_timer;
2019 else
2020 de->media_timer.function = de21041_media_timer;
2021 de->media_timer.data = (unsigned long) de;
2022
2023 netif_carrier_off(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024
2025 /* wake up device, assign resources */
2026 rc = pci_enable_device(pdev);
2027 if (rc)
2028 goto err_out_free;
2029
2030 /* reserve PCI resources to ensure driver atomicity */
2031 rc = pci_request_regions(pdev, DRV_NAME);
2032 if (rc)
2033 goto err_out_disable;
2034
2035 /* check for invalid IRQ value */
2036 if (pdev->irq < 2) {
2037 rc = -EIO;
Joe Perchesf639dc72010-01-28 20:59:19 +00002038 pr_err(PFX "invalid irq (%d) for pci dev %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 pdev->irq, pci_name(pdev));
2040 goto err_out_res;
2041 }
2042
2043 dev->irq = pdev->irq;
2044
2045 /* obtain and check validity of PCI I/O address */
2046 pciaddr = pci_resource_start(pdev, 1);
2047 if (!pciaddr) {
2048 rc = -EIO;
Joe Perchesf639dc72010-01-28 20:59:19 +00002049 pr_err(PFX "no MMIO resource for pci dev %s\n", pci_name(pdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 goto err_out_res;
2051 }
2052 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2053 rc = -EIO;
Joe Perchesf639dc72010-01-28 20:59:19 +00002054 pr_err(PFX "MMIO resource (%llx) too small on pci dev %s\n",
2055 (unsigned long long)pci_resource_len(pdev, 1),
2056 pci_name(pdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 goto err_out_res;
2058 }
2059
2060 /* remap CSR registers */
2061 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2062 if (!regs) {
2063 rc = -EIO;
Joe Perchesf639dc72010-01-28 20:59:19 +00002064 pr_err(PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2065 (unsigned long long)pci_resource_len(pdev, 1),
2066 pciaddr, pci_name(pdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 goto err_out_res;
2068 }
2069 dev->base_addr = (unsigned long) regs;
2070 de->regs = regs;
2071
2072 de_adapter_wake(de);
2073
2074 /* make sure hardware is not running */
2075 rc = de_reset_mac(de);
2076 if (rc) {
Joe Perchesf639dc72010-01-28 20:59:19 +00002077 pr_err(PFX "Cannot reset MAC, pci dev %s\n", pci_name(pdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 goto err_out_iomap;
2079 }
2080
2081 /* get MAC address, initialize default media type and
2082 * get list of supported media
2083 */
2084 if (de->de21040) {
2085 de21040_get_mac_address(de);
2086 de21040_get_media_info(de);
2087 } else {
2088 de21041_get_srom_info(de);
2089 }
2090
2091 /* register new network interface with kernel */
2092 rc = register_netdev(dev);
2093 if (rc)
2094 goto err_out_iomap;
2095
2096 /* print info about board and interface just registered */
Joe Perchesf639dc72010-01-28 20:59:19 +00002097 dev_info(&dev->dev, "%s at 0x%lx, %pM, IRQ %d\n",
2098 de->de21040 ? "21040" : "21041",
2099 dev->base_addr,
2100 dev->dev_addr,
2101 dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102
2103 pci_set_drvdata(pdev, dev);
2104
2105 /* enable busmastering */
2106 pci_set_master(pdev);
2107
2108 /* put adapter to sleep */
2109 de_adapter_sleep(de);
2110
2111 return 0;
2112
2113err_out_iomap:
Jesper Juhlb4558ea2005-10-28 16:53:13 -04002114 kfree(de->ee_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 iounmap(regs);
2116err_out_res:
2117 pci_release_regions(pdev);
2118err_out_disable:
2119 pci_disable_device(pdev);
2120err_out_free:
2121 free_netdev(dev);
2122 return rc;
2123}
2124
Helge Deller4a1d2d82006-10-06 12:12:34 -06002125static void __devexit de_remove_one (struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126{
2127 struct net_device *dev = pci_get_drvdata(pdev);
Wang Chen8f15ea42008-11-12 23:38:36 -08002128 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
Eric Sesterhenn / snakebyte7e0b58f2006-01-26 22:02:43 +01002130 BUG_ON(!dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 unregister_netdev(dev);
Jesper Juhlb4558ea2005-10-28 16:53:13 -04002132 kfree(de->ee_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 iounmap(de->regs);
2134 pci_release_regions(pdev);
2135 pci_disable_device(pdev);
2136 pci_set_drvdata(pdev, NULL);
2137 free_netdev(dev);
2138}
2139
2140#ifdef CONFIG_PM
2141
Pavel Machek05adc3b2005-04-16 15:25:25 -07002142static int de_suspend (struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143{
2144 struct net_device *dev = pci_get_drvdata (pdev);
Wang Chen8f15ea42008-11-12 23:38:36 -08002145 struct de_private *de = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
2147 rtnl_lock();
2148 if (netif_running (dev)) {
2149 del_timer_sync(&de->media_timer);
2150
2151 disable_irq(dev->irq);
2152 spin_lock_irq(&de->lock);
2153
2154 de_stop_hw(de);
2155 netif_stop_queue(dev);
2156 netif_device_detach(dev);
2157 netif_carrier_off(dev);
2158
2159 spin_unlock_irq(&de->lock);
2160 enable_irq(dev->irq);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 /* Update the error counts. */
2163 __de_get_stats(de);
2164
2165 synchronize_irq(dev->irq);
2166 de_clean_rings(de);
2167
2168 de_adapter_sleep(de);
2169 pci_disable_device(pdev);
2170 } else {
2171 netif_device_detach(dev);
2172 }
2173 rtnl_unlock();
2174 return 0;
2175}
2176
2177static int de_resume (struct pci_dev *pdev)
2178{
2179 struct net_device *dev = pci_get_drvdata (pdev);
Wang Chen8f15ea42008-11-12 23:38:36 -08002180 struct de_private *de = netdev_priv(dev);
Valerie Henson9f486ae2006-09-08 11:15:41 -07002181 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182
2183 rtnl_lock();
2184 if (netif_device_present(dev))
2185 goto out;
Valerie Henson9f486ae2006-09-08 11:15:41 -07002186 if (!netif_running(dev))
2187 goto out_attach;
2188 if ((retval = pci_enable_device(pdev))) {
Joe Perchesf639dc72010-01-28 20:59:19 +00002189 dev_err(&dev->dev, "pci_enable_device failed in resume\n");
Valerie Henson9f486ae2006-09-08 11:15:41 -07002190 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 }
Ondrej Zaryb0255a02010-09-24 23:57:02 +00002192 pci_set_master(pdev);
2193 de_init_rings(de);
Valerie Henson9f486ae2006-09-08 11:15:41 -07002194 de_init_hw(de);
2195out_attach:
2196 netif_device_attach(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197out:
2198 rtnl_unlock();
2199 return 0;
2200}
2201
2202#endif /* CONFIG_PM */
2203
2204static struct pci_driver de_driver = {
2205 .name = DRV_NAME,
2206 .id_table = de_pci_tbl,
2207 .probe = de_init_one,
Helge Deller4a1d2d82006-10-06 12:12:34 -06002208 .remove = __devexit_p(de_remove_one),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209#ifdef CONFIG_PM
2210 .suspend = de_suspend,
2211 .resume = de_resume,
2212#endif
2213};
2214
2215static int __init de_init (void)
2216{
2217#ifdef MODULE
2218 printk("%s", version);
2219#endif
Jeff Garzik29917622006-08-19 17:48:59 -04002220 return pci_register_driver(&de_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221}
2222
2223static void __exit de_exit (void)
2224{
2225 pci_unregister_driver (&de_driver);
2226}
2227
2228module_init(de_init);
2229module_exit(de_exit);