projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'tip/perf/jump-label-2' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / drivers / net / sundance.c
1 /* sundance.c: A Linux device driver for the Sundance ST201 "Alta". */
2 /*
3 Written 1999-2000 by Donald Becker.
4
5 This software may be used and distributed according to the terms of
6 the GNU General Public License (GPL), incorporated herein by reference.
7 Drivers based on or derived from this code fall under the GPL and must
8 retain the authorship, copyright and license notice. This file is not
9 a complete program and may only be used when the entire operating
10 system is licensed under the GPL.
11
12 The author may be reached as becker@scyld.com, or C/O
13 Scyld Computing Corporation
14 410 Severn Ave., Suite 210
15 Annapolis MD 21403
16
17 Support and updates available at
18 http://www.scyld.com/network/sundance.html
19 [link no longer provides useful info -jgarzik]
20 Archives of the mailing list are still available at
21 http://www.beowulf.org/pipermail/netdrivers/
22
23 */
24
25 #define DRV_NAME "sundance"
26 #define DRV_VERSION "1.2"
27 #define DRV_RELDATE "11-Sep-2006"
28
29
30 /* The user-configurable values.
31 These may be modified when a driver module is loaded.*/
32 static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
33 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
34 Typical is a 64 element hash table based on the Ethernet CRC. */
35 static const int multicast_filter_limit = 32;
36
37 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
38 Setting to > 1518 effectively disables this feature.
39 This chip can receive into offset buffers, so the Alpha does not
40 need a copy-align. */
41 static int rx_copybreak;
42 static int flowctrl=1;
43
44 /* media[] specifies the media type the NIC operates at.
45 autosense Autosensing active media.
46 10mbps_hd 10Mbps half duplex.
47 10mbps_fd 10Mbps full duplex.
48 100mbps_hd 100Mbps half duplex.
49 100mbps_fd 100Mbps full duplex.
50 0 Autosensing active media.
51 1 10Mbps half duplex.
52 2 10Mbps full duplex.
53 3 100Mbps half duplex.
54 4 100Mbps full duplex.
55 */
56 #define MAX_UNITS 8
57 static char *media[MAX_UNITS];
58
59
60 /* Operational parameters that are set at compile time. */
61
62 /* Keep the ring sizes a power of two for compile efficiency.
63 The compiler will convert <unsigned>'%'<2^N> into a bit mask.
64 Making the Tx ring too large decreases the effectiveness of channel
65 bonding and packet priority, and more than 128 requires modifying the
66 Tx error recovery.
67 Large receive rings merely waste memory. */
68 #define TX_RING_SIZE 32
69 #define TX_QUEUE_LEN (TX_RING_SIZE - 1) /* Limit ring entries actually used. */
70 #define RX_RING_SIZE 64
71 #define RX_BUDGET 32
72 #define TX_TOTAL_SIZE TX_RING_SIZE*sizeof(struct netdev_desc)
73 #define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct netdev_desc)
74
75 /* Operational parameters that usually are not changed. */
76 /* Time in jiffies before concluding the transmitter is hung. */
77 #define TX_TIMEOUT (4*HZ)
78 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
79
80 /* Include files, designed to support most kernel versions 2.0.0 and later. */
81 #include <linux/module.h>
82 #include <linux/kernel.h>
83 #include <linux/string.h>
84 #include <linux/timer.h>
85 #include <linux/errno.h>
86 #include <linux/ioport.h>
87 #include <linux/interrupt.h>
88 #include <linux/pci.h>
89 #include <linux/netdevice.h>
90 #include <linux/etherdevice.h>
91 #include <linux/skbuff.h>
92 #include <linux/init.h>
93 #include <linux/bitops.h>
94 #include <asm/uaccess.h>
95 #include <asm/processor.h> /* Processor type for cache alignment. */
96 #include <asm/io.h>
97 #include <linux/delay.h>
98 #include <linux/spinlock.h>
99 #include <linux/dma-mapping.h>
100 #include <linux/crc32.h>
101 #include <linux/ethtool.h>
102 #include <linux/mii.h>
103
104 /* These identify the driver base version and may not be removed. */
105 static const char version[] __devinitconst =
106 KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE
107 " Written by Donald Becker\n";
108
109 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
110 MODULE_DESCRIPTION("Sundance Alta Ethernet driver");
111 MODULE_LICENSE("GPL");
112
113 module_param(debug, int, 0);
114 module_param(rx_copybreak, int, 0);
115 module_param_array(media, charp, NULL, 0);
116 module_param(flowctrl, int, 0);
117 MODULE_PARM_DESC(debug, "Sundance Alta debug level (0-5)");
118 MODULE_PARM_DESC(rx_copybreak, "Sundance Alta copy breakpoint for copy-only-tiny-frames");
119 MODULE_PARM_DESC(flowctrl, "Sundance Alta flow control [0|1]");
120
121 /*
122 Theory of Operation
123
124 I. Board Compatibility
125
126 This driver is designed for the Sundance Technologies "Alta" ST201 chip.
127
128 II. Board-specific settings
129
130 III. Driver operation
131
132 IIIa. Ring buffers
133
134 This driver uses two statically allocated fixed-size descriptor lists
135 formed into rings by a branch from the final descriptor to the beginning of
136 the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
137 Some chips explicitly use only 2^N sized rings, while others use a
138 'next descriptor' pointer that the driver forms into rings.
139
140 IIIb/c. Transmit/Receive Structure
141
142 This driver uses a zero-copy receive and transmit scheme.
143 The driver allocates full frame size skbuffs for the Rx ring buffers at
144 open() time and passes the skb->data field to the chip as receive data
145 buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
146 a fresh skbuff is allocated and the frame is copied to the new skbuff.
147 When the incoming frame is larger, the skbuff is passed directly up the
148 protocol stack. Buffers consumed this way are replaced by newly allocated
149 skbuffs in a later phase of receives.
150
151 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
152 using a full-sized skbuff for small frames vs. the copying costs of larger
153 frames. New boards are typically used in generously configured machines
154 and the underfilled buffers have negligible impact compared to the benefit of
155 a single allocation size, so the default value of zero results in never
156 copying packets. When copying is done, the cost is usually mitigated by using
157 a combined copy/checksum routine. Copying also preloads the cache, which is
158 most useful with small frames.
159
160 A subtle aspect of the operation is that the IP header at offset 14 in an
161 ethernet frame isn't longword aligned for further processing.
162 Unaligned buffers are permitted by the Sundance hardware, so
163 frames are received into the skbuff at an offset of "+2", 16-byte aligning
164 the IP header.
165
166 IIId. Synchronization
167
168 The driver runs as two independent, single-threaded flows of control. One
169 is the send-packet routine, which enforces single-threaded use by the
170 dev->tbusy flag. The other thread is the interrupt handler, which is single
171 threaded by the hardware and interrupt handling software.
172
173 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
174 flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next
175 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
176 the 'lp->tx_full' flag.
177
178 The interrupt handler has exclusive control over the Rx ring and records stats
179 from the Tx ring. After reaping the stats, it marks the Tx queue entry as
180 empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
181 clears both the tx_full and tbusy flags.
182
183 IV. Notes
184
185 IVb. References
186
187 The Sundance ST201 datasheet, preliminary version.
188 The Kendin KS8723 datasheet, preliminary version.
189 The ICplus IP100 datasheet, preliminary version.
190 http://www.scyld.com/expert/100mbps.html
191 http://www.scyld.com/expert/NWay.html
192
193 IVc. Errata
194
195 */
196
197 /* Work-around for Kendin chip bugs. */
198 #ifndef CONFIG_SUNDANCE_MMIO
199 #define USE_IO_OPS 1
200 #endif
201
202 static DEFINE_PCI_DEVICE_TABLE(sundance_pci_tbl) = {
203 { 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
204 { 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
205 { 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
206 { 0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3 },
207 { 0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
208 { 0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
209 { 0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
210 { }
211 };
212 MODULE_DEVICE_TABLE(pci, sundance_pci_tbl);
213
214 enum {
215 netdev_io_size = 128
216 };
217
218 struct pci_id_info {
219 const char *name;
220 };
221 static const struct pci_id_info pci_id_tbl[] __devinitdata = {
222 {"D-Link DFE-550TX FAST Ethernet Adapter"},
223 {"D-Link DFE-550FX 100Mbps Fiber-optics Adapter"},
224 {"D-Link DFE-580TX 4 port Server Adapter"},
225 {"D-Link DFE-530TXS FAST Ethernet Adapter"},
226 {"D-Link DL10050-based FAST Ethernet Adapter"},
227 {"Sundance Technology Alta"},
228 {"IC Plus Corporation IP100A FAST Ethernet Adapter"},
229 { } /* terminate list. */
230 };
231
232 /* This driver was written to use PCI memory space, however x86-oriented
233 hardware often uses I/O space accesses. */
234
235 /* Offsets to the device registers.
236 Unlike software-only systems, device drivers interact with complex hardware.
237 It's not useful to define symbolic names for every register bit in the
238 device. The name can only partially document the semantics and make
239 the driver longer and more difficult to read.
240 In general, only the important configuration values or bits changed
241 multiple times should be defined symbolically.
242 */
243 enum alta_offsets {
244 DMACtrl = 0x00,
245 TxListPtr = 0x04,
246 TxDMABurstThresh = 0x08,
247 TxDMAUrgentThresh = 0x09,
248 TxDMAPollPeriod = 0x0a,
249 RxDMAStatus = 0x0c,
250 RxListPtr = 0x10,
251 DebugCtrl0 = 0x1a,
252 DebugCtrl1 = 0x1c,
253 RxDMABurstThresh = 0x14,
254 RxDMAUrgentThresh = 0x15,
255 RxDMAPollPeriod = 0x16,
256 LEDCtrl = 0x1a,
257 ASICCtrl = 0x30,
258 EEData = 0x34,
259 EECtrl = 0x36,
260 FlashAddr = 0x40,
261 FlashData = 0x44,
262 TxStatus = 0x46,
263 TxFrameId = 0x47,
264 DownCounter = 0x18,
265 IntrClear = 0x4a,
266 IntrEnable = 0x4c,
267 IntrStatus = 0x4e,
268 MACCtrl0 = 0x50,
269 MACCtrl1 = 0x52,
270 StationAddr = 0x54,
271 MaxFrameSize = 0x5A,
272 RxMode = 0x5c,
273 MIICtrl = 0x5e,
274 MulticastFilter0 = 0x60,
275 MulticastFilter1 = 0x64,
276 RxOctetsLow = 0x68,
277 RxOctetsHigh = 0x6a,
278 TxOctetsLow = 0x6c,
279 TxOctetsHigh = 0x6e,
280 TxFramesOK = 0x70,
281 RxFramesOK = 0x72,
282 StatsCarrierError = 0x74,
283 StatsLateColl = 0x75,
284 StatsMultiColl = 0x76,
285 StatsOneColl = 0x77,
286 StatsTxDefer = 0x78,
287 RxMissed = 0x79,
288 StatsTxXSDefer = 0x7a,
289 StatsTxAbort = 0x7b,
290 StatsBcastTx = 0x7c,
291 StatsBcastRx = 0x7d,
292 StatsMcastTx = 0x7e,
293 StatsMcastRx = 0x7f,
294 /* Aliased and bogus values! */
295 RxStatus = 0x0c,
296 };
297 enum ASICCtrl_HiWord_bit {
298 GlobalReset = 0x0001,
299 RxReset = 0x0002,
300 TxReset = 0x0004,
301 DMAReset = 0x0008,
302 FIFOReset = 0x0010,
303 NetworkReset = 0x0020,
304 HostReset = 0x0040,
305 ResetBusy = 0x0400,
306 };
307
308 /* Bits in the interrupt status/mask registers. */
309 enum intr_status_bits {
310 IntrSummary=0x0001, IntrPCIErr=0x0002, IntrMACCtrl=0x0008,
311 IntrTxDone=0x0004, IntrRxDone=0x0010, IntrRxStart=0x0020,
312 IntrDrvRqst=0x0040,
313 StatsMax=0x0080, LinkChange=0x0100,
314 IntrTxDMADone=0x0200, IntrRxDMADone=0x0400,
315 };
316
317 /* Bits in the RxMode register. */
318 enum rx_mode_bits {
319 AcceptAllIPMulti=0x20, AcceptMultiHash=0x10, AcceptAll=0x08,
320 AcceptBroadcast=0x04, AcceptMulticast=0x02, AcceptMyPhys=0x01,
321 };
322 /* Bits in MACCtrl. */
323 enum mac_ctrl0_bits {
324 EnbFullDuplex=0x20, EnbRcvLargeFrame=0x40,
325 EnbFlowCtrl=0x100, EnbPassRxCRC=0x200,
326 };
327 enum mac_ctrl1_bits {
328 StatsEnable=0x0020, StatsDisable=0x0040, StatsEnabled=0x0080,
329 TxEnable=0x0100, TxDisable=0x0200, TxEnabled=0x0400,
330 RxEnable=0x0800, RxDisable=0x1000, RxEnabled=0x2000,
331 };
332
333 /* The Rx and Tx buffer descriptors. */
334 /* Note that using only 32 bit fields simplifies conversion to big-endian
335 architectures. */
336 struct netdev_desc {
337 __le32 next_desc;
338 __le32 status;
339 struct desc_frag { __le32 addr, length; } frag[1];
340 };
341
342 /* Bits in netdev_desc.status */
343 enum desc_status_bits {
344 DescOwn=0x8000,
345 DescEndPacket=0x4000,
346 DescEndRing=0x2000,
347 LastFrag=0x80000000,
348 DescIntrOnTx=0x8000,
349 DescIntrOnDMADone=0x80000000,
350 DisableAlign = 0x00000001,
351 };
352
353 #define PRIV_ALIGN 15 /* Required alignment mask */
354 /* Use __attribute__((aligned (L1_CACHE_BYTES))) to maintain alignment
355 within the structure. */
356 #define MII_CNT 4
357 struct netdev_private {
358 /* Descriptor rings first for alignment. */
359 struct netdev_desc *rx_ring;
360 struct netdev_desc *tx_ring;
361 struct sk_buff* rx_skbuff[RX_RING_SIZE];
362 struct sk_buff* tx_skbuff[TX_RING_SIZE];
363 dma_addr_t tx_ring_dma;
364 dma_addr_t rx_ring_dma;
365 struct timer_list timer; /* Media monitoring timer. */
366 /* ethtool extra stats */
367 struct {
368 u64 tx_multiple_collisions;
369 u64 tx_single_collisions;
370 u64 tx_late_collisions;
371 u64 tx_deferred;
372 u64 tx_deferred_excessive;
373 u64 tx_aborted;
374 u64 tx_bcasts;
375 u64 rx_bcasts;
376 u64 tx_mcasts;
377 u64 rx_mcasts;
378 } xstats;
379 /* Frequently used values: keep some adjacent for cache effect. */
380 spinlock_t lock;
381 int msg_enable;
382 int chip_id;
383 unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */
384 unsigned int rx_buf_sz; /* Based on MTU+slack. */
385 struct netdev_desc *last_tx; /* Last Tx descriptor used. */
386 unsigned int cur_tx, dirty_tx;
387 /* These values are keep track of the transceiver/media in use. */
388 unsigned int flowctrl:1;
389 unsigned int default_port:4; /* Last dev->if_port value. */
390 unsigned int an_enable:1;
391 unsigned int speed;
392 struct tasklet_struct rx_tasklet;
393 struct tasklet_struct tx_tasklet;
394 int budget;
395 int cur_task;
396 /* Multicast and receive mode. */
397 spinlock_t mcastlock; /* SMP lock multicast updates. */
398 u16 mcast_filter[4];
399 /* MII transceiver section. */
400 struct mii_if_info mii_if;
401 int mii_preamble_required;
402 unsigned char phys[MII_CNT]; /* MII device addresses, only first one used. */
403 struct pci_dev *pci_dev;
404 void __iomem *base;
405 spinlock_t statlock;
406 };
407
408 /* The station address location in the EEPROM. */
409 #define EEPROM_SA_OFFSET 0x10
410 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
411 IntrDrvRqst | IntrTxDone | StatsMax | \
412 LinkChange)
413
414 static int change_mtu(struct net_device *dev, int new_mtu);
415 static int eeprom_read(void __iomem *ioaddr, int location);
416 static int mdio_read(struct net_device *dev, int phy_id, int location);
417 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
418 static int mdio_wait_link(struct net_device *dev, int wait);
419 static int netdev_open(struct net_device *dev);
420 static void check_duplex(struct net_device *dev);
421 static void netdev_timer(unsigned long data);
422 static void tx_timeout(struct net_device *dev);
423 static void init_ring(struct net_device *dev);
424 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
425 static int reset_tx (struct net_device *dev);
426 static irqreturn_t intr_handler(int irq, void *dev_instance);
427 static void rx_poll(unsigned long data);
428 static void tx_poll(unsigned long data);
429 static void refill_rx (struct net_device *dev);
430 static void netdev_error(struct net_device *dev, int intr_status);
431 static void netdev_error(struct net_device *dev, int intr_status);
432 static void set_rx_mode(struct net_device *dev);
433 static int __set_mac_addr(struct net_device *dev);
434 static struct net_device_stats *get_stats(struct net_device *dev);
435 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
436 static int netdev_close(struct net_device *dev);
437 static const struct ethtool_ops ethtool_ops;
438
439 static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
440 {
441 struct netdev_private *np = netdev_priv(dev);
442 void __iomem *ioaddr = np->base + ASICCtrl;
443 int countdown;
444
445 /* ST201 documentation states ASICCtrl is a 32bit register */
446 iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
447 /* ST201 documentation states reset can take up to 1 ms */
448 countdown = 10 + 1;
449 while (ioread32 (ioaddr) & (ResetBusy << 16)) {
450 if (--countdown == 0) {
451 printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
452 break;
453 }
454 udelay(100);
455 }
456 }
457
458 static const struct net_device_ops netdev_ops = {
459 .ndo_open = netdev_open,
460 .ndo_stop = netdev_close,
461 .ndo_start_xmit = start_tx,
462 .ndo_get_stats = get_stats,
463 .ndo_set_multicast_list = set_rx_mode,
464 .ndo_do_ioctl = netdev_ioctl,
465 .ndo_tx_timeout = tx_timeout,
466 .ndo_change_mtu = change_mtu,
467 .ndo_set_mac_address = eth_mac_addr,
468 .ndo_validate_addr = eth_validate_addr,
469 };
470
471 static int __devinit sundance_probe1 (struct pci_dev *pdev,
472 const struct pci_device_id *ent)
473 {
474 struct net_device *dev;
475 struct netdev_private *np;
476 static int card_idx;
477 int chip_idx = ent->driver_data;
478 int irq;
479 int i;
480 void __iomem *ioaddr;
481 u16 mii_ctl;
482 void *ring_space;
483 dma_addr_t ring_dma;
484 #ifdef USE_IO_OPS
485 int bar = 0;
486 #else
487 int bar = 1;
488 #endif
489 int phy, phy_end, phy_idx = 0;
490
491 /* when built into the kernel, we only print version if device is found */
492 #ifndef MODULE
493 static int printed_version;
494 if (!printed_version++)
495 printk(version);
496 #endif
497
498 if (pci_enable_device(pdev))
499 return -EIO;
500 pci_set_master(pdev);
501
502 irq = pdev->irq;
503
504 dev = alloc_etherdev(sizeof(*np));
505 if (!dev)
506 return -ENOMEM;
507 SET_NETDEV_DEV(dev, &pdev->dev);
508
509 if (pci_request_regions(pdev, DRV_NAME))
510 goto err_out_netdev;
511
512 ioaddr = pci_iomap(pdev, bar, netdev_io_size);
513 if (!ioaddr)
514 goto err_out_res;
515
516 for (i = 0; i < 3; i++)
517 ((__le16 *)dev->dev_addr)[i] =
518 cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
519 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
520
521 dev->base_addr = (unsigned long)ioaddr;
522 dev->irq = irq;
523
524 np = netdev_priv(dev);
525 np->base = ioaddr;
526 np->pci_dev = pdev;
527 np->chip_id = chip_idx;
528 np->msg_enable = (1 << debug) - 1;
529 spin_lock_init(&np->lock);
530 spin_lock_init(&np->statlock);
531 tasklet_init(&np->rx_tasklet, rx_poll, (unsigned long)dev);
532 tasklet_init(&np->tx_tasklet, tx_poll, (unsigned long)dev);
533
534 ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE,
535 &ring_dma, GFP_KERNEL);
536 if (!ring_space)
537 goto err_out_cleardev;
538 np->tx_ring = (struct netdev_desc *)ring_space;
539 np->tx_ring_dma = ring_dma;
540
541 ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE,
542 &ring_dma, GFP_KERNEL);
543 if (!ring_space)
544 goto err_out_unmap_tx;
545 np->rx_ring = (struct netdev_desc *)ring_space;
546 np->rx_ring_dma = ring_dma;
547
548 np->mii_if.dev = dev;
549 np->mii_if.mdio_read = mdio_read;
550 np->mii_if.mdio_write = mdio_write;
551 np->mii_if.phy_id_mask = 0x1f;
552 np->mii_if.reg_num_mask = 0x1f;
553
554 /* The chip-specific entries in the device structure. */
555 dev->netdev_ops = &netdev_ops;
556 SET_ETHTOOL_OPS(dev, &ethtool_ops);
557 dev->watchdog_timeo = TX_TIMEOUT;
558
559 pci_set_drvdata(pdev, dev);
560
561 i = register_netdev(dev);
562 if (i)
563 goto err_out_unmap_rx;
564
565 printk(KERN_INFO "%s: %s at %p, %pM, IRQ %d.\n",
566 dev->name, pci_id_tbl[chip_idx].name, ioaddr,
567 dev->dev_addr, irq);
568
569 np->phys[0] = 1; /* Default setting */
570 np->mii_preamble_required++;
571
572 /*
573 * It seems some phys doesn't deal well with address 0 being accessed
574 * first
575 */
576 if (sundance_pci_tbl[np->chip_id].device == 0x0200) {
577 phy = 0;
578 phy_end = 31;
579 } else {
580 phy = 1;
581 phy_end = 32; /* wraps to zero, due to 'phy & 0x1f' */
582 }
583 for (; phy <= phy_end && phy_idx < MII_CNT; phy++) {
584 int phyx = phy & 0x1f;
585 int mii_status = mdio_read(dev, phyx, MII_BMSR);
586 if (mii_status != 0xffff && mii_status != 0x0000) {
587 np->phys[phy_idx++] = phyx;
588 np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
589 if ((mii_status & 0x0040) == 0)
590 np->mii_preamble_required++;
591 printk(KERN_INFO "%s: MII PHY found at address %d, status "
592 "0x%4.4x advertising %4.4x.\n",
593 dev->name, phyx, mii_status, np->mii_if.advertising);
594 }
595 }
596 np->mii_preamble_required--;
597
598 if (phy_idx == 0) {
599 printk(KERN_INFO "%s: No MII transceiver found, aborting. ASIC status %x\n",
600 dev->name, ioread32(ioaddr + ASICCtrl));
601 goto err_out_unregister;
602 }
603
604 np->mii_if.phy_id = np->phys[0];
605
606 /* Parse override configuration */
607 np->an_enable = 1;
608 if (card_idx < MAX_UNITS) {
609 if (media[card_idx] != NULL) {
610 np->an_enable = 0;
611 if (strcmp (media[card_idx], "100mbps_fd") == 0 ||
612 strcmp (media[card_idx], "4") == 0) {
613 np->speed = 100;
614 np->mii_if.full_duplex = 1;
615 } else if (strcmp (media[card_idx], "100mbps_hd") == 0 ||
616 strcmp (media[card_idx], "3") == 0) {
617 np->speed = 100;
618 np->mii_if.full_duplex = 0;
619 } else if (strcmp (media[card_idx], "10mbps_fd") == 0 ||
620 strcmp (media[card_idx], "2") == 0) {
621 np->speed = 10;
622 np->mii_if.full_duplex = 1;
623 } else if (strcmp (media[card_idx], "10mbps_hd") == 0 ||
624 strcmp (media[card_idx], "1") == 0) {
625 np->speed = 10;
626 np->mii_if.full_duplex = 0;
627 } else {
628 np->an_enable = 1;
629 }
630 }
631 if (flowctrl == 1)
632 np->flowctrl = 1;
633 }
634
635 /* Fibre PHY? */
636 if (ioread32 (ioaddr + ASICCtrl) & 0x80) {
637 /* Default 100Mbps Full */
638 if (np->an_enable) {
639 np->speed = 100;
640 np->mii_if.full_duplex = 1;
641 np->an_enable = 0;
642 }
643 }
644 /* Reset PHY */
645 mdio_write (dev, np->phys[0], MII_BMCR, BMCR_RESET);
646 mdelay (300);
647 /* If flow control enabled, we need to advertise it.*/
648 if (np->flowctrl)
649 mdio_write (dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising | 0x0400);
650 mdio_write (dev, np->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
651 /* Force media type */
652 if (!np->an_enable) {
653 mii_ctl = 0;
654 mii_ctl |= (np->speed == 100) ? BMCR_SPEED100 : 0;
655 mii_ctl |= (np->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
656 mdio_write (dev, np->phys[0], MII_BMCR, mii_ctl);
657 printk (KERN_INFO "Override speed=%d, %s duplex\n",
658 np->speed, np->mii_if.full_duplex ? "Full" : "Half");
659
660 }
661
662 /* Perhaps move the reset here? */
663 /* Reset the chip to erase previous misconfiguration. */
664 if (netif_msg_hw(np))
665 printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));
666 sundance_reset(dev, 0x00ff << 16);
667 if (netif_msg_hw(np))
668 printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));
669
670 card_idx++;
671 return 0;
672
673 err_out_unregister:
674 unregister_netdev(dev);
675 err_out_unmap_rx:
676 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
677 np->rx_ring, np->rx_ring_dma);
678 err_out_unmap_tx:
679 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
680 np->tx_ring, np->tx_ring_dma);
681 err_out_cleardev:
682 pci_set_drvdata(pdev, NULL);
683 pci_iounmap(pdev, ioaddr);
684 err_out_res:
685 pci_release_regions(pdev);
686 err_out_netdev:
687 free_netdev (dev);
688 return -ENODEV;
689 }
690
691 static int change_mtu(struct net_device *dev, int new_mtu)
692 {
693 if ((new_mtu < 68) || (new_mtu > 8191)) /* Set by RxDMAFrameLen */
694 return -EINVAL;
695 if (netif_running(dev))
696 return -EBUSY;
697 dev->mtu = new_mtu;
698 return 0;
699 }
700
701 #define eeprom_delay(ee_addr) ioread32(ee_addr)
702 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
703 static int __devinit eeprom_read(void __iomem *ioaddr, int location)
704 {
705 int boguscnt = 10000; /* Typical 1900 ticks. */
706 iowrite16(0x0200 | (location & 0xff), ioaddr + EECtrl);
707 do {
708 eeprom_delay(ioaddr + EECtrl);
709 if (! (ioread16(ioaddr + EECtrl) & 0x8000)) {
710 return ioread16(ioaddr + EEData);
711 }
712 } while (--boguscnt > 0);
713 return 0;
714 }
715
716 /* MII transceiver control section.
717 Read and write the MII registers using software-generated serial
718 MDIO protocol. See the MII specifications or DP83840A data sheet
719 for details.
720
721 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
722 met by back-to-back 33Mhz PCI cycles. */
723 #define mdio_delay() ioread8(mdio_addr)
724
725 enum mii_reg_bits {
726 MDIO_ShiftClk=0x0001, MDIO_Data=0x0002, MDIO_EnbOutput=0x0004,
727 };
728 #define MDIO_EnbIn (0)
729 #define MDIO_WRITE0 (MDIO_EnbOutput)
730 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
731
732 /* Generate the preamble required for initial synchronization and
733 a few older transceivers. */
734 static void mdio_sync(void __iomem *mdio_addr)
735 {
736 int bits = 32;
737
738 /* Establish sync by sending at least 32 logic ones. */
739 while (--bits >= 0) {
740 iowrite8(MDIO_WRITE1, mdio_addr);
741 mdio_delay();
742 iowrite8(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
743 mdio_delay();
744 }
745 }
746
747 static int mdio_read(struct net_device *dev, int phy_id, int location)
748 {
749 struct netdev_private *np = netdev_priv(dev);
750 void __iomem *mdio_addr = np->base + MIICtrl;
751 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
752 int i, retval = 0;
753
754 if (np->mii_preamble_required)
755 mdio_sync(mdio_addr);
756
757 /* Shift the read command bits out. */
758 for (i = 15; i >= 0; i--) {
759 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
760
761 iowrite8(dataval, mdio_addr);
762 mdio_delay();
763 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
764 mdio_delay();
765 }
766 /* Read the two transition, 16 data, and wire-idle bits. */
767 for (i = 19; i > 0; i--) {
768 iowrite8(MDIO_EnbIn, mdio_addr);
769 mdio_delay();
770 retval = (retval << 1) | ((ioread8(mdio_addr) & MDIO_Data) ? 1 : 0);
771 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
772 mdio_delay();
773 }
774 return (retval>>1) & 0xffff;
775 }
776
777 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
778 {
779 struct netdev_private *np = netdev_priv(dev);
780 void __iomem *mdio_addr = np->base + MIICtrl;
781 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
782 int i;
783
784 if (np->mii_preamble_required)
785 mdio_sync(mdio_addr);
786
787 /* Shift the command bits out. */
788 for (i = 31; i >= 0; i--) {
789 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
790
791 iowrite8(dataval, mdio_addr);
792 mdio_delay();
793 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
794 mdio_delay();
795 }
796 /* Clear out extra bits. */
797 for (i = 2; i > 0; i--) {
798 iowrite8(MDIO_EnbIn, mdio_addr);
799 mdio_delay();
800 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
801 mdio_delay();
802 }
803 }
804
805 static int mdio_wait_link(struct net_device *dev, int wait)
806 {
807 int bmsr;
808 int phy_id;
809 struct netdev_private *np;
810
811 np = netdev_priv(dev);
812 phy_id = np->phys[0];
813
814 do {
815 bmsr = mdio_read(dev, phy_id, MII_BMSR);
816 if (bmsr & 0x0004)
817 return 0;
818 mdelay(1);
819 } while (--wait > 0);
820 return -1;
821 }
822
823 static int netdev_open(struct net_device *dev)
824 {
825 struct netdev_private *np = netdev_priv(dev);
826 void __iomem *ioaddr = np->base;
827 unsigned long flags;
828 int i;
829
830 /* Do we need to reset the chip??? */
831
832 i = request_irq(dev->irq, intr_handler, IRQF_SHARED, dev->name, dev);
833 if (i)
834 return i;
835
836 if (netif_msg_ifup(np))
837 printk(KERN_DEBUG "%s: netdev_open() irq %d.\n",
838 dev->name, dev->irq);
839 init_ring(dev);
840
841 iowrite32(np->rx_ring_dma, ioaddr + RxListPtr);
842 /* The Tx list pointer is written as packets are queued. */
843
844 /* Initialize other registers. */
845 __set_mac_addr(dev);
846 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
847 iowrite16(dev->mtu + 18, ioaddr + MaxFrameSize);
848 #else
849 iowrite16(dev->mtu + 14, ioaddr + MaxFrameSize);
850 #endif
851 if (dev->mtu > 2047)
852 iowrite32(ioread32(ioaddr + ASICCtrl) | 0x0C, ioaddr + ASICCtrl);
853
854 /* Configure the PCI bus bursts and FIFO thresholds. */
855
856 if (dev->if_port == 0)
857 dev->if_port = np->default_port;
858
859 spin_lock_init(&np->mcastlock);
860
861 set_rx_mode(dev);
862 iowrite16(0, ioaddr + IntrEnable);
863 iowrite16(0, ioaddr + DownCounter);
864 /* Set the chip to poll every N*320nsec. */
865 iowrite8(100, ioaddr + RxDMAPollPeriod);
866 iowrite8(127, ioaddr + TxDMAPollPeriod);
867 /* Fix DFE-580TX packet drop issue */
868 if (np->pci_dev->revision >= 0x14)
869 iowrite8(0x01, ioaddr + DebugCtrl1);
870 netif_start_queue(dev);
871
872 spin_lock_irqsave(&np->lock, flags);
873 reset_tx(dev);
874 spin_unlock_irqrestore(&np->lock, flags);
875
876 iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
877
878 if (netif_msg_ifup(np))
879 printk(KERN_DEBUG "%s: Done netdev_open(), status: Rx %x Tx %x "
880 "MAC Control %x, %4.4x %4.4x.\n",
881 dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),
882 ioread32(ioaddr + MACCtrl0),
883 ioread16(ioaddr + MACCtrl1), ioread16(ioaddr + MACCtrl0));
884
885 /* Set the timer to check for link beat. */
886 init_timer(&np->timer);
887 np->timer.expires = jiffies + 3*HZ;
888 np->timer.data = (unsigned long)dev;
889 np->timer.function = netdev_timer; /* timer handler */
890 add_timer(&np->timer);
891
892 /* Enable interrupts by setting the interrupt mask. */
893 iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
894
895 return 0;
896 }
897
898 static void check_duplex(struct net_device *dev)
899 {
900 struct netdev_private *np = netdev_priv(dev);
901 void __iomem *ioaddr = np->base;
902 int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
903 int negotiated = mii_lpa & np->mii_if.advertising;
904 int duplex;
905
906 /* Force media */
907 if (!np->an_enable || mii_lpa == 0xffff) {
908 if (np->mii_if.full_duplex)
909 iowrite16 (ioread16 (ioaddr + MACCtrl0) | EnbFullDuplex,
910 ioaddr + MACCtrl0);
911 return;
912 }
913
914 /* Autonegotiation */
915 duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
916 if (np->mii_if.full_duplex != duplex) {
917 np->mii_if.full_duplex = duplex;
918 if (netif_msg_link(np))
919 printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d "
920 "negotiated capability %4.4x.\n", dev->name,
921 duplex ? "full" : "half", np->phys[0], negotiated);
922 iowrite16(ioread16(ioaddr + MACCtrl0) | (duplex ? 0x20 : 0), ioaddr + MACCtrl0);
923 }
924 }
925
926 static void netdev_timer(unsigned long data)
927 {
928 struct net_device *dev = (struct net_device *)data;
929 struct netdev_private *np = netdev_priv(dev);
930 void __iomem *ioaddr = np->base;
931 int next_tick = 10*HZ;
932
933 if (netif_msg_timer(np)) {
934 printk(KERN_DEBUG "%s: Media selection timer tick, intr status %4.4x, "
935 "Tx %x Rx %x.\n",
936 dev->name, ioread16(ioaddr + IntrEnable),
937 ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));
938 }
939 check_duplex(dev);
940 np->timer.expires = jiffies + next_tick;
941 add_timer(&np->timer);
942 }
943
944 static void tx_timeout(struct net_device *dev)
945 {
946 struct netdev_private *np = netdev_priv(dev);
947 void __iomem *ioaddr = np->base;
948 unsigned long flag;
949
950 netif_stop_queue(dev);
951 tasklet_disable(&np->tx_tasklet);
952 iowrite16(0, ioaddr + IntrEnable);
953 printk(KERN_WARNING "%s: Transmit timed out, TxStatus %2.2x "
954 "TxFrameId %2.2x,"
955 " resetting...\n", dev->name, ioread8(ioaddr + TxStatus),
956 ioread8(ioaddr + TxFrameId));
957
958 {
959 int i;
960 for (i=0; i<TX_RING_SIZE; i++) {
961 printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
962 (unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)),
963 le32_to_cpu(np->tx_ring[i].next_desc),
964 le32_to_cpu(np->tx_ring[i].status),
965 (le32_to_cpu(np->tx_ring[i].status) >> 2) & 0xff,
966 le32_to_cpu(np->tx_ring[i].frag[0].addr),
967 le32_to_cpu(np->tx_ring[i].frag[0].length));
968 }
969 printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n",
970 ioread32(np->base + TxListPtr),
971 netif_queue_stopped(dev));
972 printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n",
973 np->cur_tx, np->cur_tx % TX_RING_SIZE,
974 np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
975 printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
976 printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
977 }
978 spin_lock_irqsave(&np->lock, flag);
979
980 /* Stop and restart the chip's Tx processes . */
981 reset_tx(dev);
982 spin_unlock_irqrestore(&np->lock, flag);
983
984 dev->if_port = 0;
985
986 dev->trans_start = jiffies; /* prevent tx timeout */
987 dev->stats.tx_errors++;
988 if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
989 netif_wake_queue(dev);
990 }
991 iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
992 tasklet_enable(&np->tx_tasklet);
993 }
994
995
996 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
997 static void init_ring(struct net_device *dev)
998 {
999 struct netdev_private *np = netdev_priv(dev);
1000 int i;
1001
1002 np->cur_rx = np->cur_tx = 0;
1003 np->dirty_rx = np->dirty_tx = 0;
1004 np->cur_task = 0;
1005
1006 np->rx_buf_sz = (dev->mtu <= 1520 ? PKT_BUF_SZ : dev->mtu + 16);
1007
1008 /* Initialize all Rx descriptors. */
1009 for (i = 0; i < RX_RING_SIZE; i++) {
1010 np->rx_ring[i].next_desc = cpu_to_le32(np->rx_ring_dma +
1011 ((i+1)%RX_RING_SIZE)*sizeof(*np->rx_ring));
1012 np->rx_ring[i].status = 0;
1013 np->rx_ring[i].frag[0].length = 0;
1014 np->rx_skbuff[i] = NULL;
1015 }
1016
1017 /* Fill in the Rx buffers. Handle allocation failure gracefully. */
1018 for (i = 0; i < RX_RING_SIZE; i++) {
1019 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
1020 np->rx_skbuff[i] = skb;
1021 if (skb == NULL)
1022 break;
1023 skb->dev = dev; /* Mark as being used by this device. */
1024 skb_reserve(skb, 2); /* 16 byte align the IP header. */
1025 np->rx_ring[i].frag[0].addr = cpu_to_le32(
1026 dma_map_single(&np->pci_dev->dev, skb->data,
1027 np->rx_buf_sz, DMA_FROM_DEVICE));
1028 if (dma_mapping_error(&np->pci_dev->dev,
1029 np->rx_ring[i].frag[0].addr)) {
1030 dev_kfree_skb(skb);
1031 np->rx_skbuff[i] = NULL;
1032 break;
1033 }
1034 np->rx_ring[i].frag[0].length = cpu_to_le32(np->rx_buf_sz | LastFrag);
1035 }
1036 np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1037
1038 for (i = 0; i < TX_RING_SIZE; i++) {
1039 np->tx_skbuff[i] = NULL;
1040 np->tx_ring[i].status = 0;
1041 }
1042 }
1043
1044 static void tx_poll (unsigned long data)
1045 {
1046 struct net_device *dev = (struct net_device *)data;
1047 struct netdev_private *np = netdev_priv(dev);
1048 unsigned head = np->cur_task % TX_RING_SIZE;
1049 struct netdev_desc *txdesc =
1050 &np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE];
1051
1052 /* Chain the next pointer */
1053 for (; np->cur_tx - np->cur_task > 0; np->cur_task++) {
1054 int entry = np->cur_task % TX_RING_SIZE;
1055 txdesc = &np->tx_ring[entry];
1056 if (np->last_tx) {
1057 np->last_tx->next_desc = cpu_to_le32(np->tx_ring_dma +
1058 entry*sizeof(struct netdev_desc));
1059 }
1060 np->last_tx = txdesc;
1061 }
1062 /* Indicate the latest descriptor of tx ring */
1063 txdesc->status |= cpu_to_le32(DescIntrOnTx);
1064
1065 if (ioread32 (np->base + TxListPtr) == 0)
1066 iowrite32 (np->tx_ring_dma + head * sizeof(struct netdev_desc),
1067 np->base + TxListPtr);
1068 }
1069
1070 static netdev_tx_t
1071 start_tx (struct sk_buff *skb, struct net_device *dev)
1072 {
1073 struct netdev_private *np = netdev_priv(dev);
1074 struct netdev_desc *txdesc;
1075 unsigned entry;
1076
1077 /* Calculate the next Tx descriptor entry. */
1078 entry = np->cur_tx % TX_RING_SIZE;
1079 np->tx_skbuff[entry] = skb;
1080 txdesc = &np->tx_ring[entry];
1081
1082 txdesc->next_desc = 0;
1083 txdesc->status = cpu_to_le32 ((entry << 2) | DisableAlign);
1084 txdesc->frag[0].addr = cpu_to_le32(dma_map_single(&np->pci_dev->dev,
1085 skb->data, skb->len, DMA_TO_DEVICE));
1086 if (dma_mapping_error(&np->pci_dev->dev,
1087 txdesc->frag[0].addr))
1088 goto drop_frame;
1089 txdesc->frag[0].length = cpu_to_le32 (skb->len | LastFrag);
1090
1091 /* Increment cur_tx before tasklet_schedule() */
1092 np->cur_tx++;
1093 mb();
1094 /* Schedule a tx_poll() task */
1095 tasklet_schedule(&np->tx_tasklet);
1096
1097 /* On some architectures: explicitly flush cache lines here. */
1098 if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 1 &&
1099 !netif_queue_stopped(dev)) {
1100 /* do nothing */
1101 } else {
1102 netif_stop_queue (dev);
1103 }
1104 if (netif_msg_tx_queued(np)) {
1105 printk (KERN_DEBUG
1106 "%s: Transmit frame #%d queued in slot %d.\n",
1107 dev->name, np->cur_tx, entry);
1108 }
1109 return NETDEV_TX_OK;
1110
1111 drop_frame:
1112 dev_kfree_skb(skb);
1113 np->tx_skbuff[entry] = NULL;
1114 dev->stats.tx_dropped++;
1115 return NETDEV_TX_OK;
1116 }
1117
1118 /* Reset hardware tx and free all of tx buffers */
1119 static int
1120 reset_tx (struct net_device *dev)
1121 {
1122 struct netdev_private *np = netdev_priv(dev);
1123 void __iomem *ioaddr = np->base;
1124 struct sk_buff *skb;
1125 int i;
1126
1127 /* Reset tx logic, TxListPtr will be cleaned */
1128 iowrite16 (TxDisable, ioaddr + MACCtrl1);
1129 sundance_reset(dev, (NetworkReset|FIFOReset|DMAReset|TxReset) << 16);
1130
1131 /* free all tx skbuff */
1132 for (i = 0; i < TX_RING_SIZE; i++) {
1133 np->tx_ring[i].next_desc = 0;
1134
1135 skb = np->tx_skbuff[i];
1136 if (skb) {
1137 dma_unmap_single(&np->pci_dev->dev,
1138 le32_to_cpu(np->tx_ring[i].frag[0].addr),
1139 skb->len, DMA_TO_DEVICE);
1140 dev_kfree_skb_any(skb);
1141 np->tx_skbuff[i] = NULL;
1142 dev->stats.tx_dropped++;
1143 }
1144 }
1145 np->cur_tx = np->dirty_tx = 0;
1146 np->cur_task = 0;
1147
1148 np->last_tx = NULL;
1149 iowrite8(127, ioaddr + TxDMAPollPeriod);
1150
1151 iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
1152 return 0;
1153 }
1154
1155 /* The interrupt handler cleans up after the Tx thread,
1156 and schedule a Rx thread work */
1157 static irqreturn_t intr_handler(int irq, void *dev_instance)
1158 {
1159 struct net_device *dev = (struct net_device *)dev_instance;
1160 struct netdev_private *np = netdev_priv(dev);
1161 void __iomem *ioaddr = np->base;
1162 int hw_frame_id;
1163 int tx_cnt;
1164 int tx_status;
1165 int handled = 0;
1166 int i;
1167
1168
1169 do {
1170 int intr_status = ioread16(ioaddr + IntrStatus);
1171 iowrite16(intr_status, ioaddr + IntrStatus);
1172
1173 if (netif_msg_intr(np))
1174 printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n",
1175 dev->name, intr_status);
1176
1177 if (!(intr_status & DEFAULT_INTR))
1178 break;
1179
1180 handled = 1;
1181
1182 if (intr_status & (IntrRxDMADone)) {
1183 iowrite16(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone),
1184 ioaddr + IntrEnable);
1185 if (np->budget < 0)
1186 np->budget = RX_BUDGET;
1187 tasklet_schedule(&np->rx_tasklet);
1188 }
1189 if (intr_status & (IntrTxDone | IntrDrvRqst)) {
1190 tx_status = ioread16 (ioaddr + TxStatus);
1191 for (tx_cnt=32; tx_status & 0x80; --tx_cnt) {
1192 if (netif_msg_tx_done(np))
1193 printk
1194 ("%s: Transmit status is %2.2x.\n",
1195 dev->name, tx_status);
1196 if (tx_status & 0x1e) {
1197 if (netif_msg_tx_err(np))
1198 printk("%s: Transmit error status %4.4x.\n",
1199 dev->name, tx_status);
1200 dev->stats.tx_errors++;
1201 if (tx_status & 0x10)
1202 dev->stats.tx_fifo_errors++;
1203 if (tx_status & 0x08)
1204 dev->stats.collisions++;
1205 if (tx_status & 0x04)
1206 dev->stats.tx_fifo_errors++;
1207 if (tx_status & 0x02)
1208 dev->stats.tx_window_errors++;
1209
1210 /*
1211 ** This reset has been verified on
1212 ** DFE-580TX boards ! phdm@macqel.be.
1213 */
1214 if (tx_status & 0x10) { /* TxUnderrun */
1215 /* Restart Tx FIFO and transmitter */
1216 sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
1217 /* No need to reset the Tx pointer here */
1218 }
1219 /* Restart the Tx. Need to make sure tx enabled */
1220 i = 10;
1221 do {
1222 iowrite16(ioread16(ioaddr + MACCtrl1) | TxEnable, ioaddr + MACCtrl1);
1223 if (ioread16(ioaddr + MACCtrl1) & TxEnabled)
1224 break;
1225 mdelay(1);
1226 } while (--i);
1227 }
1228 /* Yup, this is a documentation bug. It cost me *hours*. */
1229 iowrite16 (0, ioaddr + TxStatus);
1230 if (tx_cnt < 0) {
1231 iowrite32(5000, ioaddr + DownCounter);
1232 break;
1233 }
1234 tx_status = ioread16 (ioaddr + TxStatus);
1235 }
1236 hw_frame_id = (tx_status >> 8) & 0xff;
1237 } else {
1238 hw_frame_id = ioread8(ioaddr + TxFrameId);
1239 }
1240
1241 if (np->pci_dev->revision >= 0x14) {
1242 spin_lock(&np->lock);
1243 for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1244 int entry = np->dirty_tx % TX_RING_SIZE;
1245 struct sk_buff *skb;
1246 int sw_frame_id;
1247 sw_frame_id = (le32_to_cpu(
1248 np->tx_ring[entry].status) >> 2) & 0xff;
1249 if (sw_frame_id == hw_frame_id &&
1250 !(le32_to_cpu(np->tx_ring[entry].status)
1251 & 0x00010000))
1252 break;
1253 if (sw_frame_id == (hw_frame_id + 1) %
1254 TX_RING_SIZE)
1255 break;
1256 skb = np->tx_skbuff[entry];
1257 /* Free the original skb. */
1258 dma_unmap_single(&np->pci_dev->dev,
1259 le32_to_cpu(np->tx_ring[entry].frag[0].addr),
1260 skb->len, DMA_TO_DEVICE);
1261 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1262 np->tx_skbuff[entry] = NULL;
1263 np->tx_ring[entry].frag[0].addr = 0;
1264 np->tx_ring[entry].frag[0].length = 0;
1265 }
1266 spin_unlock(&np->lock);
1267 } else {
1268 spin_lock(&np->lock);
1269 for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1270 int entry = np->dirty_tx % TX_RING_SIZE;
1271 struct sk_buff *skb;
1272 if (!(le32_to_cpu(np->tx_ring[entry].status)
1273 & 0x00010000))
1274 break;
1275 skb = np->tx_skbuff[entry];
1276 /* Free the original skb. */
1277 dma_unmap_single(&np->pci_dev->dev,
1278 le32_to_cpu(np->tx_ring[entry].frag[0].addr),
1279 skb->len, DMA_TO_DEVICE);
1280 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1281 np->tx_skbuff[entry] = NULL;
1282 np->tx_ring[entry].frag[0].addr = 0;
1283 np->tx_ring[entry].frag[0].length = 0;
1284 }
1285 spin_unlock(&np->lock);
1286 }
1287
1288 if (netif_queue_stopped(dev) &&
1289 np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1290 /* The ring is no longer full, clear busy flag. */
1291 netif_wake_queue (dev);
1292 }
1293 /* Abnormal error summary/uncommon events handlers. */
1294 if (intr_status & (IntrPCIErr | LinkChange | StatsMax))
1295 netdev_error(dev, intr_status);
1296 } while (0);
1297 if (netif_msg_intr(np))
1298 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1299 dev->name, ioread16(ioaddr + IntrStatus));
1300 return IRQ_RETVAL(handled);
1301 }
1302
1303 static void rx_poll(unsigned long data)
1304 {
1305 struct net_device *dev = (struct net_device *)data;
1306 struct netdev_private *np = netdev_priv(dev);
1307 int entry = np->cur_rx % RX_RING_SIZE;
1308 int boguscnt = np->budget;
1309 void __iomem *ioaddr = np->base;
1310 int received = 0;
1311
1312 /* If EOP is set on the next entry, it's a new packet. Send it up. */
1313 while (1) {
1314 struct netdev_desc *desc = &(np->rx_ring[entry]);
1315 u32 frame_status = le32_to_cpu(desc->status);
1316 int pkt_len;
1317
1318 if (--boguscnt < 0) {
1319 goto not_done;
1320 }
1321 if (!(frame_status & DescOwn))
1322 break;
1323 pkt_len = frame_status & 0x1fff; /* Chip omits the CRC. */
1324 if (netif_msg_rx_status(np))
1325 printk(KERN_DEBUG " netdev_rx() status was %8.8x.\n",
1326 frame_status);
1327 if (frame_status & 0x001f4000) {
1328 /* There was a error. */
1329 if (netif_msg_rx_err(np))
1330 printk(KERN_DEBUG " netdev_rx() Rx error was %8.8x.\n",
1331 frame_status);
1332 dev->stats.rx_errors++;
1333 if (frame_status & 0x00100000)
1334 dev->stats.rx_length_errors++;
1335 if (frame_status & 0x00010000)
1336 dev->stats.rx_fifo_errors++;
1337 if (frame_status & 0x00060000)
1338 dev->stats.rx_frame_errors++;
1339 if (frame_status & 0x00080000)
1340 dev->stats.rx_crc_errors++;
1341 if (frame_status & 0x00100000) {
1342 printk(KERN_WARNING "%s: Oversized Ethernet frame,"
1343 " status %8.8x.\n",
1344 dev->name, frame_status);
1345 }
1346 } else {
1347 struct sk_buff *skb;
1348 #ifndef final_version
1349 if (netif_msg_rx_status(np))
1350 printk(KERN_DEBUG " netdev_rx() normal Rx pkt length %d"
1351 ", bogus_cnt %d.\n",
1352 pkt_len, boguscnt);
1353 #endif
1354 /* Check if the packet is long enough to accept without copying
1355 to a minimally-sized skbuff. */
1356 if (pkt_len < rx_copybreak &&
1357 (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1358 skb_reserve(skb, 2); /* 16 byte align the IP header */
1359 dma_sync_single_for_cpu(&np->pci_dev->dev,
1360 le32_to_cpu(desc->frag[0].addr),
1361 np->rx_buf_sz, DMA_FROM_DEVICE);
1362 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1363 dma_sync_single_for_device(&np->pci_dev->dev,
1364 le32_to_cpu(desc->frag[0].addr),
1365 np->rx_buf_sz, DMA_FROM_DEVICE);
1366 skb_put(skb, pkt_len);
1367 } else {
1368 dma_unmap_single(&np->pci_dev->dev,
1369 le32_to_cpu(desc->frag[0].addr),
1370 np->rx_buf_sz, DMA_FROM_DEVICE);
1371 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1372 np->rx_skbuff[entry] = NULL;
1373 }
1374 skb->protocol = eth_type_trans(skb, dev);
1375 /* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */
1376 netif_rx(skb);
1377 }
1378 entry = (entry + 1) % RX_RING_SIZE;
1379 received++;
1380 }
1381 np->cur_rx = entry;
1382 refill_rx (dev);
1383 np->budget -= received;
1384 iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1385 return;
1386
1387 not_done:
1388 np->cur_rx = entry;
1389 refill_rx (dev);
1390 if (!received)
1391 received = 1;
1392 np->budget -= received;
1393 if (np->budget <= 0)
1394 np->budget = RX_BUDGET;
1395 tasklet_schedule(&np->rx_tasklet);
1396 }
1397
1398 static void refill_rx (struct net_device *dev)
1399 {
1400 struct netdev_private *np = netdev_priv(dev);
1401 int entry;
1402 int cnt = 0;
1403
1404 /* Refill the Rx ring buffers. */
1405 for (;(np->cur_rx - np->dirty_rx + RX_RING_SIZE) % RX_RING_SIZE > 0;
1406 np->dirty_rx = (np->dirty_rx + 1) % RX_RING_SIZE) {
1407 struct sk_buff *skb;
1408 entry = np->dirty_rx % RX_RING_SIZE;
1409 if (np->rx_skbuff[entry] == NULL) {
1410 skb = dev_alloc_skb(np->rx_buf_sz);
1411 np->rx_skbuff[entry] = skb;
1412 if (skb == NULL)
1413 break; /* Better luck next round. */
1414 skb->dev = dev; /* Mark as being used by this device. */
1415 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1416 np->rx_ring[entry].frag[0].addr = cpu_to_le32(
1417 dma_map_single(&np->pci_dev->dev, skb->data,
1418 np->rx_buf_sz, DMA_FROM_DEVICE));
1419 if (dma_mapping_error(&np->pci_dev->dev,
1420 np->rx_ring[entry].frag[0].addr)) {
1421 dev_kfree_skb_irq(skb);
1422 np->rx_skbuff[entry] = NULL;
1423 break;
1424 }
1425 }
1426 /* Perhaps we need not reset this field. */
1427 np->rx_ring[entry].frag[0].length =
1428 cpu_to_le32(np->rx_buf_sz | LastFrag);
1429 np->rx_ring[entry].status = 0;
1430 cnt++;
1431 }
1432 }
1433 static void netdev_error(struct net_device *dev, int intr_status)
1434 {
1435 struct netdev_private *np = netdev_priv(dev);
1436 void __iomem *ioaddr = np->base;
1437 u16 mii_ctl, mii_advertise, mii_lpa;
1438 int speed;
1439
1440 if (intr_status & LinkChange) {
1441 if (mdio_wait_link(dev, 10) == 0) {
1442 printk(KERN_INFO "%s: Link up\n", dev->name);
1443 if (np->an_enable) {
1444 mii_advertise = mdio_read(dev, np->phys[0],
1445 MII_ADVERTISE);
1446 mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
1447 mii_advertise &= mii_lpa;
1448 printk(KERN_INFO "%s: Link changed: ",
1449 dev->name);
1450 if (mii_advertise & ADVERTISE_100FULL) {
1451 np->speed = 100;
1452 printk("100Mbps, full duplex\n");
1453 } else if (mii_advertise & ADVERTISE_100HALF) {
1454 np->speed = 100;
1455 printk("100Mbps, half duplex\n");
1456 } else if (mii_advertise & ADVERTISE_10FULL) {
1457 np->speed = 10;
1458 printk("10Mbps, full duplex\n");
1459 } else if (mii_advertise & ADVERTISE_10HALF) {
1460 np->speed = 10;
1461 printk("10Mbps, half duplex\n");
1462 } else
1463 printk("\n");
1464
1465 } else {
1466 mii_ctl = mdio_read(dev, np->phys[0], MII_BMCR);
1467 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
1468 np->speed = speed;
1469 printk(KERN_INFO "%s: Link changed: %dMbps ,",
1470 dev->name, speed);
1471 printk("%s duplex.\n",
1472 (mii_ctl & BMCR_FULLDPLX) ?
1473 "full" : "half");
1474 }
1475 check_duplex(dev);
1476 if (np->flowctrl && np->mii_if.full_duplex) {
1477 iowrite16(ioread16(ioaddr + MulticastFilter1+2) | 0x0200,
1478 ioaddr + MulticastFilter1+2);
1479 iowrite16(ioread16(ioaddr + MACCtrl0) | EnbFlowCtrl,
1480 ioaddr + MACCtrl0);
1481 }
1482 netif_carrier_on(dev);
1483 } else {
1484 printk(KERN_INFO "%s: Link down\n", dev->name);
1485 netif_carrier_off(dev);
1486 }
1487 }
1488 if (intr_status & StatsMax) {
1489 get_stats(dev);
1490 }
1491 if (intr_status & IntrPCIErr) {
1492 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1493 dev->name, intr_status);
1494 /* We must do a global reset of DMA to continue. */
1495 }
1496 }
1497
1498 static struct net_device_stats *get_stats(struct net_device *dev)
1499 {
1500 struct netdev_private *np = netdev_priv(dev);
1501 void __iomem *ioaddr = np->base;
1502 unsigned long flags;
1503 u8 late_coll, single_coll, mult_coll;
1504
1505 spin_lock_irqsave(&np->statlock, flags);
1506 /* The chip only need report frame silently dropped. */
1507 dev->stats.rx_missed_errors += ioread8(ioaddr + RxMissed);
1508 dev->stats.tx_packets += ioread16(ioaddr + TxFramesOK);
1509 dev->stats.rx_packets += ioread16(ioaddr + RxFramesOK);
1510 dev->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);
1511
1512 mult_coll = ioread8(ioaddr + StatsMultiColl);
1513 np->xstats.tx_multiple_collisions += mult_coll;
1514 single_coll = ioread8(ioaddr + StatsOneColl);
1515 np->xstats.tx_single_collisions += single_coll;
1516 late_coll = ioread8(ioaddr + StatsLateColl);
1517 np->xstats.tx_late_collisions += late_coll;
1518 dev->stats.collisions += mult_coll
1519 + single_coll
1520 + late_coll;
1521
1522 np->xstats.tx_deferred += ioread8(ioaddr + StatsTxDefer);
1523 np->xstats.tx_deferred_excessive += ioread8(ioaddr + StatsTxXSDefer);
1524 np->xstats.tx_aborted += ioread8(ioaddr + StatsTxAbort);
1525 np->xstats.tx_bcasts += ioread8(ioaddr + StatsBcastTx);
1526 np->xstats.rx_bcasts += ioread8(ioaddr + StatsBcastRx);
1527 np->xstats.tx_mcasts += ioread8(ioaddr + StatsMcastTx);
1528 np->xstats.rx_mcasts += ioread8(ioaddr + StatsMcastRx);
1529
1530 dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsLow);
1531 dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsHigh) << 16;
1532 dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsLow);
1533 dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsHigh) << 16;
1534
1535 spin_unlock_irqrestore(&np->statlock, flags);
1536
1537 return &dev->stats;
1538 }
1539
1540 static void set_rx_mode(struct net_device *dev)
1541 {
1542 struct netdev_private *np = netdev_priv(dev);
1543 void __iomem *ioaddr = np->base;
1544 u16 mc_filter[4]; /* Multicast hash filter */
1545 u32 rx_mode;
1546 int i;
1547
1548 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1549 memset(mc_filter, 0xff, sizeof(mc_filter));
1550 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys;
1551 } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1552 (dev->flags & IFF_ALLMULTI)) {
1553 /* Too many to match, or accept all multicasts. */
1554 memset(mc_filter, 0xff, sizeof(mc_filter));
1555 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1556 } else if (!netdev_mc_empty(dev)) {
1557 struct netdev_hw_addr *ha;
1558 int bit;
1559 int index;
1560 int crc;
1561 memset (mc_filter, 0, sizeof (mc_filter));
1562 netdev_for_each_mc_addr(ha, dev) {
1563 crc = ether_crc_le(ETH_ALEN, ha->addr);
1564 for (index=0, bit=0; bit < 6; bit++, crc <<= 1)
1565 if (crc & 0x80000000) index |= 1 << bit;
1566 mc_filter[index/16] |= (1 << (index % 16));
1567 }
1568 rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys;
1569 } else {
1570 iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1571 return;
1572 }
1573 if (np->mii_if.full_duplex && np->flowctrl)
1574 mc_filter[3] |= 0x0200;
1575
1576 for (i = 0; i < 4; i++)
1577 iowrite16(mc_filter[i], ioaddr + MulticastFilter0 + i*2);
1578 iowrite8(rx_mode, ioaddr + RxMode);
1579 }
1580
1581 static int __set_mac_addr(struct net_device *dev)
1582 {
1583 struct netdev_private *np = netdev_priv(dev);
1584 u16 addr16;
1585
1586 addr16 = (dev->dev_addr[0] | (dev->dev_addr[1] << 8));
1587 iowrite16(addr16, np->base + StationAddr);
1588 addr16 = (dev->dev_addr[2] | (dev->dev_addr[3] << 8));
1589 iowrite16(addr16, np->base + StationAddr+2);
1590 addr16 = (dev->dev_addr[4] | (dev->dev_addr[5] << 8));
1591 iowrite16(addr16, np->base + StationAddr+4);
1592 return 0;
1593 }
1594
1595 static const struct {
1596 const char name[ETH_GSTRING_LEN];
1597 } sundance_stats[] = {
1598 { "tx_multiple_collisions" },
1599 { "tx_single_collisions" },
1600 { "tx_late_collisions" },
1601 { "tx_deferred" },
1602 { "tx_deferred_excessive" },
1603 { "tx_aborted" },
1604 { "tx_bcasts" },
1605 { "rx_bcasts" },
1606 { "tx_mcasts" },
1607 { "rx_mcasts" },
1608 };
1609
1610 static int check_if_running(struct net_device *dev)
1611 {
1612 if (!netif_running(dev))
1613 return -EINVAL;
1614 return 0;
1615 }
1616
1617 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1618 {
1619 struct netdev_private *np = netdev_priv(dev);
1620 strcpy(info->driver, DRV_NAME);
1621 strcpy(info->version, DRV_VERSION);
1622 strcpy(info->bus_info, pci_name(np->pci_dev));
1623 }
1624
1625 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1626 {
1627 struct netdev_private *np = netdev_priv(dev);
1628 spin_lock_irq(&np->lock);
1629 mii_ethtool_gset(&np->mii_if, ecmd);
1630 spin_unlock_irq(&np->lock);
1631 return 0;
1632 }
1633
1634 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1635 {
1636 struct netdev_private *np = netdev_priv(dev);
1637 int res;
1638 spin_lock_irq(&np->lock);
1639 res = mii_ethtool_sset(&np->mii_if, ecmd);
1640 spin_unlock_irq(&np->lock);
1641 return res;
1642 }
1643
1644 static int nway_reset(struct net_device *dev)
1645 {
1646 struct netdev_private *np = netdev_priv(dev);
1647 return mii_nway_restart(&np->mii_if);
1648 }
1649
1650 static u32 get_link(struct net_device *dev)
1651 {
1652 struct netdev_private *np = netdev_priv(dev);
1653 return mii_link_ok(&np->mii_if);
1654 }
1655
1656 static u32 get_msglevel(struct net_device *dev)
1657 {
1658 struct netdev_private *np = netdev_priv(dev);
1659 return np->msg_enable;
1660 }
1661
1662 static void set_msglevel(struct net_device *dev, u32 val)
1663 {
1664 struct netdev_private *np = netdev_priv(dev);
1665 np->msg_enable = val;
1666 }
1667
1668 static void get_strings(struct net_device *dev, u32 stringset,
1669 u8 *data)
1670 {
1671 if (stringset == ETH_SS_STATS)
1672 memcpy(data, sundance_stats, sizeof(sundance_stats));
1673 }
1674
1675 static int get_sset_count(struct net_device *dev, int sset)
1676 {
1677 switch (sset) {
1678 case ETH_SS_STATS:
1679 return ARRAY_SIZE(sundance_stats);
1680 default:
1681 return -EOPNOTSUPP;
1682 }
1683 }
1684
1685 static void get_ethtool_stats(struct net_device *dev,
1686 struct ethtool_stats *stats, u64 *data)
1687 {
1688 struct netdev_private *np = netdev_priv(dev);
1689 int i = 0;
1690
1691 get_stats(dev);
1692 data[i++] = np->xstats.tx_multiple_collisions;
1693 data[i++] = np->xstats.tx_single_collisions;
1694 data[i++] = np->xstats.tx_late_collisions;
1695 data[i++] = np->xstats.tx_deferred;
1696 data[i++] = np->xstats.tx_deferred_excessive;
1697 data[i++] = np->xstats.tx_aborted;
1698 data[i++] = np->xstats.tx_bcasts;
1699 data[i++] = np->xstats.rx_bcasts;
1700 data[i++] = np->xstats.tx_mcasts;
1701 data[i++] = np->xstats.rx_mcasts;
1702 }
1703
1704 static const struct ethtool_ops ethtool_ops = {
1705 .begin = check_if_running,
1706 .get_drvinfo = get_drvinfo,
1707 .get_settings = get_settings,
1708 .set_settings = set_settings,
1709 .nway_reset = nway_reset,
1710 .get_link = get_link,
1711 .get_msglevel = get_msglevel,
1712 .set_msglevel = set_msglevel,
1713 .get_strings = get_strings,
1714 .get_sset_count = get_sset_count,
1715 .get_ethtool_stats = get_ethtool_stats,
1716 };
1717
1718 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1719 {
1720 struct netdev_private *np = netdev_priv(dev);
1721 int rc;
1722
1723 if (!netif_running(dev))
1724 return -EINVAL;
1725
1726 spin_lock_irq(&np->lock);
1727 rc = generic_mii_ioctl(&np->mii_if, if_mii(rq), cmd, NULL);
1728 spin_unlock_irq(&np->lock);
1729
1730 return rc;
1731 }
1732
1733 static int netdev_close(struct net_device *dev)
1734 {
1735 struct netdev_private *np = netdev_priv(dev);
1736 void __iomem *ioaddr = np->base;
1737 struct sk_buff *skb;
1738 int i;
1739
1740 /* Wait and kill tasklet */
1741 tasklet_kill(&np->rx_tasklet);
1742 tasklet_kill(&np->tx_tasklet);
1743 np->cur_tx = 0;
1744 np->dirty_tx = 0;
1745 np->cur_task = 0;
1746 np->last_tx = NULL;
1747
1748 netif_stop_queue(dev);
1749
1750 if (netif_msg_ifdown(np)) {
1751 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x "
1752 "Rx %4.4x Int %2.2x.\n",
1753 dev->name, ioread8(ioaddr + TxStatus),
1754 ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));
1755 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
1756 dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
1757 }
1758
1759 /* Disable interrupts by clearing the interrupt mask. */
1760 iowrite16(0x0000, ioaddr + IntrEnable);
1761
1762 /* Disable Rx and Tx DMA for safely release resource */
1763 iowrite32(0x500, ioaddr + DMACtrl);
1764
1765 /* Stop the chip's Tx and Rx processes. */
1766 iowrite16(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1);
1767
1768 for (i = 2000; i > 0; i--) {
1769 if ((ioread32(ioaddr + DMACtrl) & 0xc000) == 0)
1770 break;
1771 mdelay(1);
1772 }
1773
1774 iowrite16(GlobalReset | DMAReset | FIFOReset | NetworkReset,
1775 ioaddr +ASICCtrl + 2);
1776
1777 for (i = 2000; i > 0; i--) {
1778 if ((ioread16(ioaddr + ASICCtrl +2) & ResetBusy) == 0)
1779 break;
1780 mdelay(1);
1781 }
1782
1783 #ifdef __i386__
1784 if (netif_msg_hw(np)) {
1785 printk(KERN_DEBUG " Tx ring at %8.8x:\n",
1786 (int)(np->tx_ring_dma));
1787 for (i = 0; i < TX_RING_SIZE; i++)
1788 printk(KERN_DEBUG " #%d desc. %4.4x %8.8x %8.8x.\n",
1789 i, np->tx_ring[i].status, np->tx_ring[i].frag[0].addr,
1790 np->tx_ring[i].frag[0].length);
1791 printk(KERN_DEBUG " Rx ring %8.8x:\n",
1792 (int)(np->rx_ring_dma));
1793 for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
1794 printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
1795 i, np->rx_ring[i].status, np->rx_ring[i].frag[0].addr,
1796 np->rx_ring[i].frag[0].length);
1797 }
1798 }
1799 #endif /* __i386__ debugging only */
1800
1801 free_irq(dev->irq, dev);
1802
1803 del_timer_sync(&np->timer);
1804
1805 /* Free all the skbuffs in the Rx queue. */
1806 for (i = 0; i < RX_RING_SIZE; i++) {
1807 np->rx_ring[i].status = 0;
1808 skb = np->rx_skbuff[i];
1809 if (skb) {
1810 dma_unmap_single(&np->pci_dev->dev,
1811 le32_to_cpu(np->rx_ring[i].frag[0].addr),
1812 np->rx_buf_sz, DMA_FROM_DEVICE);
1813 dev_kfree_skb(skb);
1814 np->rx_skbuff[i] = NULL;
1815 }
1816 np->rx_ring[i].frag[0].addr = cpu_to_le32(0xBADF00D0); /* poison */
1817 }
1818 for (i = 0; i < TX_RING_SIZE; i++) {
1819 np->tx_ring[i].next_desc = 0;
1820 skb = np->tx_skbuff[i];
1821 if (skb) {
1822 dma_unmap_single(&np->pci_dev->dev,
1823 le32_to_cpu(np->tx_ring[i].frag[0].addr),
1824 skb->len, DMA_TO_DEVICE);
1825 dev_kfree_skb(skb);
1826 np->tx_skbuff[i] = NULL;
1827 }
1828 }
1829
1830 return 0;
1831 }
1832
1833 static void __devexit sundance_remove1 (struct pci_dev *pdev)
1834 {
1835 struct net_device *dev = pci_get_drvdata(pdev);
1836
1837 if (dev) {
1838 struct netdev_private *np = netdev_priv(dev);
1839 unregister_netdev(dev);
1840 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
1841 np->rx_ring, np->rx_ring_dma);
1842 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
1843 np->tx_ring, np->tx_ring_dma);
1844 pci_iounmap(pdev, np->base);
1845 pci_release_regions(pdev);
1846 free_netdev(dev);
1847 pci_set_drvdata(pdev, NULL);
1848 }
1849 }
1850
1851 #ifdef CONFIG_PM
1852
1853 static int sundance_suspend(struct pci_dev *pci_dev, pm_message_t state)
1854 {
1855 struct net_device *dev = pci_get_drvdata(pci_dev);
1856
1857 if (!netif_running(dev))
1858 return 0;
1859
1860 netdev_close(dev);
1861 netif_device_detach(dev);
1862
1863 pci_save_state(pci_dev);
1864 pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
1865
1866 return 0;
1867 }
1868
1869 static int sundance_resume(struct pci_dev *pci_dev)
1870 {
1871 struct net_device *dev = pci_get_drvdata(pci_dev);
1872 int err = 0;
1873
1874 if (!netif_running(dev))
1875 return 0;
1876
1877 pci_set_power_state(pci_dev, PCI_D0);
1878 pci_restore_state(pci_dev);
1879
1880 err = netdev_open(dev);
1881 if (err) {
1882 printk(KERN_ERR "%s: Can't resume interface!\n",
1883 dev->name);
1884 goto out;
1885 }
1886
1887 netif_device_attach(dev);
1888
1889 out:
1890 return err;
1891 }
1892
1893 #endif /* CONFIG_PM */
1894
1895 static struct pci_driver sundance_driver = {
1896 .name = DRV_NAME,
1897 .id_table = sundance_pci_tbl,
1898 .probe = sundance_probe1,
1899 .remove = __devexit_p(sundance_remove1),
1900 #ifdef CONFIG_PM
1901 .suspend = sundance_suspend,
1902 .resume = sundance_resume,
1903 #endif /* CONFIG_PM */
1904 };
1905
1906 static int __init sundance_init(void)
1907 {
1908 /* when a module, this is printed whether or not devices are found in probe */
1909 #ifdef MODULE
1910 printk(version);
1911 #endif
1912 return pci_register_driver(&sundance_driver);
1913 }
1914
1915 static void __exit sundance_exit(void)
1916 {
1917 pci_unregister_driver(&sundance_driver);
1918 }
1919
1920 module_init(sundance_init);
1921 module_exit(sundance_exit);
1922
1923
Linux kernel - Deliverables
This page took 0.079774 seconds and 5 git commands to generate.