1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
48
49#define DRV_NAME "winbond-840"
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66static int debug = 1;
67static int max_interrupt_work = 20;
68
69
70static int multicast_filter_limit = 32;
71
72
73
74static int rx_copybreak;
75
76
77
78
79
80
81#define MAX_UNITS 8
82static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
83static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
84
85
86
87
88
89
90
91
92#define TX_QUEUE_LEN 10
93#define TX_QUEUE_LEN_RESTART 5
94
95#define TX_BUFLIMIT (1024-128)
96
97
98
99
100
101#define TX_FIFO_SIZE (2048)
102#define TX_BUG_FIFO_LIMIT (TX_FIFO_SIZE-1514-16)
103
104
105
106
107#define TX_TIMEOUT (2*HZ)
108
109
110#include <linux/module.h>
111#include <linux/kernel.h>
112#include <linux/string.h>
113#include <linux/timer.h>
114#include <linux/errno.h>
115#include <linux/ioport.h>
116#include <linux/interrupt.h>
117#include <linux/pci.h>
118#include <linux/dma-mapping.h>
119#include <linux/netdevice.h>
120#include <linux/etherdevice.h>
121#include <linux/skbuff.h>
122#include <linux/init.h>
123#include <linux/delay.h>
124#include <linux/ethtool.h>
125#include <linux/mii.h>
126#include <linux/rtnetlink.h>
127#include <linux/crc32.h>
128#include <linux/bitops.h>
129#include <linux/uaccess.h>
130#include <asm/processor.h>
131#include <asm/io.h>
132#include <asm/irq.h>
133
134#include "tulip.h"
135
136#undef PKT_BUF_SZ
137#define PKT_BUF_SZ 1536
138
139MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
140MODULE_DESCRIPTION("Winbond W89c840 Ethernet driver");
141MODULE_LICENSE("GPL");
142
143module_param(max_interrupt_work, int, 0);
144module_param(debug, int, 0);
145module_param(rx_copybreak, int, 0);
146module_param(multicast_filter_limit, int, 0);
147module_param_array(options, int, NULL, 0);
148module_param_array(full_duplex, int, NULL, 0);
149MODULE_PARM_DESC(max_interrupt_work, "winbond-840 maximum events handled per interrupt");
150MODULE_PARM_DESC(debug, "winbond-840 debug level (0-6)");
151MODULE_PARM_DESC(rx_copybreak, "winbond-840 copy breakpoint for copy-only-tiny-frames");
152MODULE_PARM_DESC(multicast_filter_limit, "winbond-840 maximum number of filtered multicast addresses");
153MODULE_PARM_DESC(options, "winbond-840: Bits 0-3: media type, bit 17: full duplex");
154MODULE_PARM_DESC(full_duplex, "winbond-840 full duplex setting(s) (1)");
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208enum chip_capability_flags {
209 CanHaveMII=1, HasBrokenTx=2, AlwaysFDX=4, FDXOnNoMII=8,
210};
211
212static const struct pci_device_id w840_pci_tbl[] = {
213 { 0x1050, 0x0840, PCI_ANY_ID, 0x8153, 0, 0, 0 },
214 { 0x1050, 0x0840, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
215 { 0x11f6, 0x2011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
216 { }
217};
218MODULE_DEVICE_TABLE(pci, w840_pci_tbl);
219
220enum {
221 netdev_res_size = 128,
222};
223
224struct pci_id_info {
225 const char *name;
226 int drv_flags;
227};
228
229static const struct pci_id_info pci_id_tbl[] = {
230 {
231 "Winbond W89c840", CanHaveMII | HasBrokenTx | FDXOnNoMII},
232 { "Winbond W89c840", CanHaveMII | HasBrokenTx},
233 { "Compex RL100-ATX", CanHaveMII | HasBrokenTx},
234 { }
235};
236
237
238
239
240
241
242
243
244
245
246
247enum w840_offsets {
248 PCIBusCfg=0x00, TxStartDemand=0x04, RxStartDemand=0x08,
249 RxRingPtr=0x0C, TxRingPtr=0x10,
250 IntrStatus=0x14, NetworkConfig=0x18, IntrEnable=0x1C,
251 RxMissed=0x20, EECtrl=0x24, MIICtrl=0x24, BootRom=0x28, GPTimer=0x2C,
252 CurRxDescAddr=0x30, CurRxBufAddr=0x34,
253 MulticastFilter0=0x38, MulticastFilter1=0x3C, StationAddr=0x40,
254 CurTxDescAddr=0x4C, CurTxBufAddr=0x50,
255};
256
257
258enum rx_mode_bits {
259 AcceptErr=0x80,
260 RxAcceptBroadcast=0x20, AcceptMulticast=0x10,
261 RxAcceptAllPhys=0x08, AcceptMyPhys=0x02,
262};
263
264enum mii_reg_bits {
265 MDIO_ShiftClk=0x10000, MDIO_DataIn=0x80000, MDIO_DataOut=0x20000,
266 MDIO_EnbOutput=0x40000, MDIO_EnbIn = 0x00000,
267};
268
269
270struct w840_rx_desc {
271 s32 status;
272 s32 length;
273 u32 buffer1;
274 u32 buffer2;
275};
276
277struct w840_tx_desc {
278 s32 status;
279 s32 length;
280 u32 buffer1, buffer2;
281};
282
283#define MII_CNT 1
284struct netdev_private {
285 struct w840_rx_desc *rx_ring;
286 dma_addr_t rx_addr[RX_RING_SIZE];
287 struct w840_tx_desc *tx_ring;
288 dma_addr_t tx_addr[TX_RING_SIZE];
289 dma_addr_t ring_dma_addr;
290
291 struct sk_buff* rx_skbuff[RX_RING_SIZE];
292
293 struct sk_buff* tx_skbuff[TX_RING_SIZE];
294 struct net_device_stats stats;
295 struct timer_list timer;
296
297 spinlock_t lock;
298 int chip_id, drv_flags;
299 struct pci_dev *pci_dev;
300 int csr6;
301 struct w840_rx_desc *rx_head_desc;
302 unsigned int cur_rx, dirty_rx;
303 unsigned int rx_buf_sz;
304 unsigned int cur_tx, dirty_tx;
305 unsigned int tx_q_bytes;
306 unsigned int tx_full;
307
308 int mii_cnt;
309 unsigned char phys[MII_CNT];
310 u32 mii;
311 struct mii_if_info mii_if;
312 void __iomem *base_addr;
313};
314
315static int eeprom_read(void __iomem *ioaddr, int location);
316static int mdio_read(struct net_device *dev, int phy_id, int location);
317static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
318static int netdev_open(struct net_device *dev);
319static int update_link(struct net_device *dev);
320static void netdev_timer(struct timer_list *t);
321static void init_rxtx_rings(struct net_device *dev);
322static void free_rxtx_rings(struct netdev_private *np);
323static void init_registers(struct net_device *dev);
324static void tx_timeout(struct net_device *dev, unsigned int txqueue);
325static int alloc_ringdesc(struct net_device *dev);
326static void free_ringdesc(struct netdev_private *np);
327static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
328static irqreturn_t intr_handler(int irq, void *dev_instance);
329static void netdev_error(struct net_device *dev, int intr_status);
330static int netdev_rx(struct net_device *dev);
331static u32 __set_rx_mode(struct net_device *dev);
332static void set_rx_mode(struct net_device *dev);
333static struct net_device_stats *get_stats(struct net_device *dev);
334static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
335static const struct ethtool_ops netdev_ethtool_ops;
336static int netdev_close(struct net_device *dev);
337
338static const struct net_device_ops netdev_ops = {
339 .ndo_open = netdev_open,
340 .ndo_stop = netdev_close,
341 .ndo_start_xmit = start_tx,
342 .ndo_get_stats = get_stats,
343 .ndo_set_rx_mode = set_rx_mode,
344 .ndo_do_ioctl = netdev_ioctl,
345 .ndo_tx_timeout = tx_timeout,
346 .ndo_set_mac_address = eth_mac_addr,
347 .ndo_validate_addr = eth_validate_addr,
348};
349
350static int w840_probe1(struct pci_dev *pdev, const struct pci_device_id *ent)
351{
352 struct net_device *dev;
353 struct netdev_private *np;
354 static int find_cnt;
355 int chip_idx = ent->driver_data;
356 int irq;
357 int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
358 void __iomem *ioaddr;
359
360 i = pcim_enable_device(pdev);
361 if (i) return i;
362
363 pci_set_master(pdev);
364
365 irq = pdev->irq;
366
367 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
368 pr_warn("Device %s disabled due to DMA limitations\n",
369 pci_name(pdev));
370 return -EIO;
371 }
372 dev = alloc_etherdev(sizeof(*np));
373 if (!dev)
374 return -ENOMEM;
375 SET_NETDEV_DEV(dev, &pdev->dev);
376
377 if (pci_request_regions(pdev, DRV_NAME))
378 goto err_out_netdev;
379
380 ioaddr = pci_iomap(pdev, TULIP_BAR, netdev_res_size);
381 if (!ioaddr)
382 goto err_out_netdev;
383
384 for (i = 0; i < 3; i++)
385 ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(eeprom_read(ioaddr, i));
386
387
388
389 iowrite32(0x00000001, ioaddr + PCIBusCfg);
390
391 np = netdev_priv(dev);
392 np->pci_dev = pdev;
393 np->chip_id = chip_idx;
394 np->drv_flags = pci_id_tbl[chip_idx].drv_flags;
395 spin_lock_init(&np->lock);
396 np->mii_if.dev = dev;
397 np->mii_if.mdio_read = mdio_read;
398 np->mii_if.mdio_write = mdio_write;
399 np->base_addr = ioaddr;
400
401 pci_set_drvdata(pdev, dev);
402
403 if (dev->mem_start)
404 option = dev->mem_start;
405
406
407 if (option > 0) {
408 if (option & 0x200)
409 np->mii_if.full_duplex = 1;
410 if (option & 15)
411 dev_info(&dev->dev,
412 "ignoring user supplied media type %d",
413 option & 15);
414 }
415 if (find_cnt < MAX_UNITS && full_duplex[find_cnt] > 0)
416 np->mii_if.full_duplex = 1;
417
418 if (np->mii_if.full_duplex)
419 np->mii_if.force_media = 1;
420
421
422 dev->netdev_ops = &netdev_ops;
423 dev->ethtool_ops = &netdev_ethtool_ops;
424 dev->watchdog_timeo = TX_TIMEOUT;
425
426 i = register_netdev(dev);
427 if (i)
428 goto err_out_cleardev;
429
430 dev_info(&dev->dev, "%s at %p, %pM, IRQ %d\n",
431 pci_id_tbl[chip_idx].name, ioaddr, dev->dev_addr, irq);
432
433 if (np->drv_flags & CanHaveMII) {
434 int phy, phy_idx = 0;
435 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
436 int mii_status = mdio_read(dev, phy, MII_BMSR);
437 if (mii_status != 0xffff && mii_status != 0x0000) {
438 np->phys[phy_idx++] = phy;
439 np->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
440 np->mii = (mdio_read(dev, phy, MII_PHYSID1) << 16)+
441 mdio_read(dev, phy, MII_PHYSID2);
442 dev_info(&dev->dev,
443 "MII PHY %08xh found at address %d, status 0x%04x advertising %04x\n",
444 np->mii, phy, mii_status,
445 np->mii_if.advertising);
446 }
447 }
448 np->mii_cnt = phy_idx;
449 np->mii_if.phy_id = np->phys[0];
450 if (phy_idx == 0) {
451 dev_warn(&dev->dev,
452 "MII PHY not found -- this device may not operate correctly\n");
453 }
454 }
455
456 find_cnt++;
457 return 0;
458
459err_out_cleardev:
460 pci_iounmap(pdev, ioaddr);
461err_out_netdev:
462 free_netdev (dev);
463 return -ENODEV;
464}
465
466
467
468
469
470
471
472
473
474
475
476
477
478#define eeprom_delay(ee_addr) ioread32(ee_addr)
479
480enum EEPROM_Ctrl_Bits {
481 EE_ShiftClk=0x02, EE_Write0=0x801, EE_Write1=0x805,
482 EE_ChipSelect=0x801, EE_DataIn=0x08,
483};
484
485
486enum EEPROM_Cmds {
487 EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
488};
489
490static int eeprom_read(void __iomem *addr, int location)
491{
492 int i;
493 int retval = 0;
494 void __iomem *ee_addr = addr + EECtrl;
495 int read_cmd = location | EE_ReadCmd;
496 iowrite32(EE_ChipSelect, ee_addr);
497
498
499 for (i = 10; i >= 0; i--) {
500 short dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0;
501 iowrite32(dataval, ee_addr);
502 eeprom_delay(ee_addr);
503 iowrite32(dataval | EE_ShiftClk, ee_addr);
504 eeprom_delay(ee_addr);
505 }
506 iowrite32(EE_ChipSelect, ee_addr);
507 eeprom_delay(ee_addr);
508
509 for (i = 16; i > 0; i--) {
510 iowrite32(EE_ChipSelect | EE_ShiftClk, ee_addr);
511 eeprom_delay(ee_addr);
512 retval = (retval << 1) | ((ioread32(ee_addr) & EE_DataIn) ? 1 : 0);
513 iowrite32(EE_ChipSelect, ee_addr);
514 eeprom_delay(ee_addr);
515 }
516
517
518 iowrite32(0, ee_addr);
519 return retval;
520}
521
522
523
524
525
526
527
528
529#define mdio_delay(mdio_addr) ioread32(mdio_addr)
530
531
532
533
534static char mii_preamble_required = 1;
535
536#define MDIO_WRITE0 (MDIO_EnbOutput)
537#define MDIO_WRITE1 (MDIO_DataOut | MDIO_EnbOutput)
538
539
540
541static void mdio_sync(void __iomem *mdio_addr)
542{
543 int bits = 32;
544
545
546 while (--bits >= 0) {
547 iowrite32(MDIO_WRITE1, mdio_addr);
548 mdio_delay(mdio_addr);
549 iowrite32(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
550 mdio_delay(mdio_addr);
551 }
552}
553
554static int mdio_read(struct net_device *dev, int phy_id, int location)
555{
556 struct netdev_private *np = netdev_priv(dev);
557 void __iomem *mdio_addr = np->base_addr + MIICtrl;
558 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
559 int i, retval = 0;
560
561 if (mii_preamble_required)
562 mdio_sync(mdio_addr);
563
564
565 for (i = 15; i >= 0; i--) {
566 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
567
568 iowrite32(dataval, mdio_addr);
569 mdio_delay(mdio_addr);
570 iowrite32(dataval | MDIO_ShiftClk, mdio_addr);
571 mdio_delay(mdio_addr);
572 }
573
574 for (i = 20; i > 0; i--) {
575 iowrite32(MDIO_EnbIn, mdio_addr);
576 mdio_delay(mdio_addr);
577 retval = (retval << 1) | ((ioread32(mdio_addr) & MDIO_DataIn) ? 1 : 0);
578 iowrite32(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
579 mdio_delay(mdio_addr);
580 }
581 return (retval>>1) & 0xffff;
582}
583
584static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
585{
586 struct netdev_private *np = netdev_priv(dev);
587 void __iomem *mdio_addr = np->base_addr + MIICtrl;
588 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
589 int i;
590
591 if (location == 4 && phy_id == np->phys[0])
592 np->mii_if.advertising = value;
593
594 if (mii_preamble_required)
595 mdio_sync(mdio_addr);
596
597
598 for (i = 31; i >= 0; i--) {
599 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
600
601 iowrite32(dataval, mdio_addr);
602 mdio_delay(mdio_addr);
603 iowrite32(dataval | MDIO_ShiftClk, mdio_addr);
604 mdio_delay(mdio_addr);
605 }
606
607 for (i = 2; i > 0; i--) {
608 iowrite32(MDIO_EnbIn, mdio_addr);
609 mdio_delay(mdio_addr);
610 iowrite32(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
611 mdio_delay(mdio_addr);
612 }
613}
614
615
616static int netdev_open(struct net_device *dev)
617{
618 struct netdev_private *np = netdev_priv(dev);
619 void __iomem *ioaddr = np->base_addr;
620 const int irq = np->pci_dev->irq;
621 int i;
622
623 iowrite32(0x00000001, ioaddr + PCIBusCfg);
624
625 netif_device_detach(dev);
626 i = request_irq(irq, intr_handler, IRQF_SHARED, dev->name, dev);
627 if (i)
628 goto out_err;
629
630 if (debug > 1)
631 netdev_dbg(dev, "%s() irq %d\n", __func__, irq);
632
633 i = alloc_ringdesc(dev);
634 if (i)
635 goto out_err;
636
637 spin_lock_irq(&np->lock);
638 netif_device_attach(dev);
639 init_registers(dev);
640 spin_unlock_irq(&np->lock);
641
642 netif_start_queue(dev);
643 if (debug > 2)
644 netdev_dbg(dev, "Done %s()\n", __func__);
645
646
647 timer_setup(&np->timer, netdev_timer, 0);
648 np->timer.expires = jiffies + 1*HZ;
649 add_timer(&np->timer);
650 return 0;
651out_err:
652 netif_device_attach(dev);
653 return i;
654}
655
656#define MII_DAVICOM_DM9101 0x0181b800
657
658static int update_link(struct net_device *dev)
659{
660 struct netdev_private *np = netdev_priv(dev);
661 int duplex, fasteth, result, mii_reg;
662
663
664 mii_reg = mdio_read(dev, np->phys[0], MII_BMSR);
665
666 if (mii_reg == 0xffff)
667 return np->csr6;
668
669 mii_reg = mdio_read(dev, np->phys[0], MII_BMSR);
670 if (!(mii_reg & 0x4)) {
671 if (netif_carrier_ok(dev)) {
672 if (debug)
673 dev_info(&dev->dev,
674 "MII #%d reports no link. Disabling watchdog\n",
675 np->phys[0]);
676 netif_carrier_off(dev);
677 }
678 return np->csr6;
679 }
680 if (!netif_carrier_ok(dev)) {
681 if (debug)
682 dev_info(&dev->dev,
683 "MII #%d link is back. Enabling watchdog\n",
684 np->phys[0]);
685 netif_carrier_on(dev);
686 }
687
688 if ((np->mii & ~0xf) == MII_DAVICOM_DM9101) {
689
690
691
692
693
694
695
696
697 mii_reg = mdio_read(dev, np->phys[0], MII_BMCR);
698 duplex = mii_reg & BMCR_FULLDPLX;
699 fasteth = mii_reg & BMCR_SPEED100;
700 } else {
701 int negotiated;
702 mii_reg = mdio_read(dev, np->phys[0], MII_LPA);
703 negotiated = mii_reg & np->mii_if.advertising;
704
705 duplex = (negotiated & LPA_100FULL) || ((negotiated & 0x02C0) == LPA_10FULL);
706 fasteth = negotiated & 0x380;
707 }
708 duplex |= np->mii_if.force_media;
709
710 result = np->csr6 & ~0x20000200;
711 if (duplex)
712 result |= 0x200;
713 if (fasteth)
714 result |= 0x20000000;
715 if (result != np->csr6 && debug)
716 dev_info(&dev->dev,
717 "Setting %dMBit-%s-duplex based on MII#%d\n",
718 fasteth ? 100 : 10, duplex ? "full" : "half",
719 np->phys[0]);
720 return result;
721}
722
723#define RXTX_TIMEOUT 2000
724static inline void update_csr6(struct net_device *dev, int new)
725{
726 struct netdev_private *np = netdev_priv(dev);
727 void __iomem *ioaddr = np->base_addr;
728 int limit = RXTX_TIMEOUT;
729
730 if (!netif_device_present(dev))
731 new = 0;
732 if (new==np->csr6)
733 return;
734
735 iowrite32(np->csr6 & ~0x2002, ioaddr + NetworkConfig);
736
737 for (;;) {
738 int csr5 = ioread32(ioaddr + IntrStatus);
739 int t;
740
741 t = (csr5 >> 17) & 0x07;
742 if (t==0||t==1) {
743
744 t = (csr5 >> 20) & 0x07;
745 if (t==0||t==1)
746 break;
747 }
748
749 limit--;
750 if(!limit) {
751 dev_info(&dev->dev,
752 "couldn't stop rxtx, IntrStatus %xh\n", csr5);
753 break;
754 }
755 udelay(1);
756 }
757 np->csr6 = new;
758
759 iowrite32(np->csr6, ioaddr + NetworkConfig);
760 if (new & 0x200)
761 np->mii_if.full_duplex = 1;
762}
763
764static void netdev_timer(struct timer_list *t)
765{
766 struct netdev_private *np = from_timer(np, t, timer);
767 struct net_device *dev = pci_get_drvdata(np->pci_dev);
768 void __iomem *ioaddr = np->base_addr;
769
770 if (debug > 2)
771 netdev_dbg(dev, "Media selection timer tick, status %08x config %08x\n",
772 ioread32(ioaddr + IntrStatus),
773 ioread32(ioaddr + NetworkConfig));
774 spin_lock_irq(&np->lock);
775 update_csr6(dev, update_link(dev));
776 spin_unlock_irq(&np->lock);
777 np->timer.expires = jiffies + 10*HZ;
778 add_timer(&np->timer);
779}
780
781static void init_rxtx_rings(struct net_device *dev)
782{
783 struct netdev_private *np = netdev_priv(dev);
784 int i;
785
786 np->rx_head_desc = &np->rx_ring[0];
787 np->tx_ring = (struct w840_tx_desc*)&np->rx_ring[RX_RING_SIZE];
788
789
790 for (i = 0; i < RX_RING_SIZE; i++) {
791 np->rx_ring[i].length = np->rx_buf_sz;
792 np->rx_ring[i].status = 0;
793 np->rx_skbuff[i] = NULL;
794 }
795
796 np->rx_ring[i-1].length |= DescEndRing;
797
798
799 for (i = 0; i < RX_RING_SIZE; i++) {
800 struct sk_buff *skb = netdev_alloc_skb(dev, np->rx_buf_sz);
801 np->rx_skbuff[i] = skb;
802 if (skb == NULL)
803 break;
804 np->rx_addr[i] = dma_map_single(&np->pci_dev->dev, skb->data,
805 np->rx_buf_sz,
806 DMA_FROM_DEVICE);
807
808 np->rx_ring[i].buffer1 = np->rx_addr[i];
809 np->rx_ring[i].status = DescOwned;
810 }
811
812 np->cur_rx = 0;
813 np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
814
815
816 for (i = 0; i < TX_RING_SIZE; i++) {
817 np->tx_skbuff[i] = NULL;
818 np->tx_ring[i].status = 0;
819 }
820 np->tx_full = 0;
821 np->tx_q_bytes = np->dirty_tx = np->cur_tx = 0;
822
823 iowrite32(np->ring_dma_addr, np->base_addr + RxRingPtr);
824 iowrite32(np->ring_dma_addr+sizeof(struct w840_rx_desc)*RX_RING_SIZE,
825 np->base_addr + TxRingPtr);
826
827}
828
829static void free_rxtx_rings(struct netdev_private* np)
830{
831 int i;
832
833 for (i = 0; i < RX_RING_SIZE; i++) {
834 np->rx_ring[i].status = 0;
835 if (np->rx_skbuff[i]) {
836 dma_unmap_single(&np->pci_dev->dev, np->rx_addr[i],
837 np->rx_skbuff[i]->len,
838 DMA_FROM_DEVICE);
839 dev_kfree_skb(np->rx_skbuff[i]);
840 }
841 np->rx_skbuff[i] = NULL;
842 }
843 for (i = 0; i < TX_RING_SIZE; i++) {
844 if (np->tx_skbuff[i]) {
845 dma_unmap_single(&np->pci_dev->dev, np->tx_addr[i],
846 np->tx_skbuff[i]->len, DMA_TO_DEVICE);
847 dev_kfree_skb(np->tx_skbuff[i]);
848 }
849 np->tx_skbuff[i] = NULL;
850 }
851}
852
853static void init_registers(struct net_device *dev)
854{
855 struct netdev_private *np = netdev_priv(dev);
856 void __iomem *ioaddr = np->base_addr;
857 int i;
858
859 for (i = 0; i < 6; i++)
860 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
861
862
863#ifdef __BIG_ENDIAN
864 i = (1<<20);
865#else
866 i = 0;
867#endif
868 i |= (0x04<<2);
869 i |= 0x02;
870
871
872
873
874
875
876
877
878
879
880#if defined (__i386__) && !defined(MODULE)
881
882 if (boot_cpu_data.x86 <= 4) {
883 i |= 0x4800;
884 dev_info(&dev->dev,
885 "This is a 386/486 PCI system, setting cache alignment to 8 longwords\n");
886 } else {
887 i |= 0xE000;
888 }
889#elif defined(__powerpc__) || defined(__i386__) || defined(__alpha__) || defined(__ia64__) || defined(__x86_64__)
890 i |= 0xE000;
891#elif defined(CONFIG_SPARC) || defined (CONFIG_PARISC) || defined(CONFIG_ARM)
892 i |= 0x4800;
893#else
894 dev_warn(&dev->dev, "unknown CPU architecture, using default csr0 setting\n");
895 i |= 0x4800;
896#endif
897 iowrite32(i, ioaddr + PCIBusCfg);
898
899 np->csr6 = 0;
900
901
902 update_csr6(dev, 0x00022002 | update_link(dev) | __set_rx_mode(dev));
903
904
905 iowrite32(0x1A0F5, ioaddr + IntrStatus);
906 iowrite32(0x1A0F5, ioaddr + IntrEnable);
907
908 iowrite32(0, ioaddr + RxStartDemand);
909}
910
911static void tx_timeout(struct net_device *dev, unsigned int txqueue)
912{
913 struct netdev_private *np = netdev_priv(dev);
914 void __iomem *ioaddr = np->base_addr;
915 const int irq = np->pci_dev->irq;
916
917 dev_warn(&dev->dev, "Transmit timed out, status %08x, resetting...\n",
918 ioread32(ioaddr + IntrStatus));
919
920 {
921 int i;
922 printk(KERN_DEBUG " Rx ring %p: ", np->rx_ring);
923 for (i = 0; i < RX_RING_SIZE; i++)
924 printk(KERN_CONT " %08x", (unsigned int)np->rx_ring[i].status);
925 printk(KERN_CONT "\n");
926 printk(KERN_DEBUG " Tx ring %p: ", np->tx_ring);
927 for (i = 0; i < TX_RING_SIZE; i++)
928 printk(KERN_CONT " %08x", np->tx_ring[i].status);
929 printk(KERN_CONT "\n");
930 }
931 printk(KERN_DEBUG "Tx cur %d Tx dirty %d Tx Full %d, q bytes %d\n",
932 np->cur_tx, np->dirty_tx, np->tx_full, np->tx_q_bytes);
933 printk(KERN_DEBUG "Tx Descriptor addr %xh\n", ioread32(ioaddr+0x4C));
934
935 disable_irq(irq);
936 spin_lock_irq(&np->lock);
937
938
939
940
941
942
943 iowrite32(1, np->base_addr+PCIBusCfg);
944 udelay(1);
945
946 free_rxtx_rings(np);
947 init_rxtx_rings(dev);
948 init_registers(dev);
949 spin_unlock_irq(&np->lock);
950 enable_irq(irq);
951
952 netif_wake_queue(dev);
953 netif_trans_update(dev);
954 np->stats.tx_errors++;
955}
956
957
958static int alloc_ringdesc(struct net_device *dev)
959{
960 struct netdev_private *np = netdev_priv(dev);
961
962 np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
963
964 np->rx_ring = dma_alloc_coherent(&np->pci_dev->dev,
965 sizeof(struct w840_rx_desc) * RX_RING_SIZE +
966 sizeof(struct w840_tx_desc) * TX_RING_SIZE,
967 &np->ring_dma_addr, GFP_KERNEL);
968 if(!np->rx_ring)
969 return -ENOMEM;
970 init_rxtx_rings(dev);
971 return 0;
972}
973
974static void free_ringdesc(struct netdev_private *np)
975{
976 dma_free_coherent(&np->pci_dev->dev,
977 sizeof(struct w840_rx_desc) * RX_RING_SIZE +
978 sizeof(struct w840_tx_desc) * TX_RING_SIZE,
979 np->rx_ring, np->ring_dma_addr);
980
981}
982
983static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
984{
985 struct netdev_private *np = netdev_priv(dev);
986 unsigned entry;
987
988
989
990
991
992 entry = np->cur_tx % TX_RING_SIZE;
993
994 np->tx_addr[entry] = dma_map_single(&np->pci_dev->dev, skb->data,
995 skb->len, DMA_TO_DEVICE);
996 np->tx_skbuff[entry] = skb;
997
998 np->tx_ring[entry].buffer1 = np->tx_addr[entry];
999 if (skb->len < TX_BUFLIMIT) {
1000 np->tx_ring[entry].length = DescWholePkt | skb->len;
1001 } else {
1002 int len = skb->len - TX_BUFLIMIT;
1003
1004 np->tx_ring[entry].buffer2 = np->tx_addr[entry]+TX_BUFLIMIT;
1005 np->tx_ring[entry].length = DescWholePkt | (len << 11) | TX_BUFLIMIT;
1006 }
1007 if(entry == TX_RING_SIZE-1)
1008 np->tx_ring[entry].length |= DescEndRing;
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020 spin_lock_irq(&np->lock);
1021 np->cur_tx++;
1022
1023 wmb();
1024 np->tx_ring[entry].status = DescOwned;
1025 wmb();
1026 iowrite32(0, np->base_addr + TxStartDemand);
1027 np->tx_q_bytes += skb->len;
1028
1029
1030 if (np->cur_tx - np->dirty_tx > TX_QUEUE_LEN ||
1031 ((np->drv_flags & HasBrokenTx) && np->tx_q_bytes > TX_BUG_FIFO_LIMIT)) {
1032 netif_stop_queue(dev);
1033 wmb();
1034 np->tx_full = 1;
1035 }
1036 spin_unlock_irq(&np->lock);
1037
1038 if (debug > 4) {
1039 netdev_dbg(dev, "Transmit frame #%d queued in slot %d\n",
1040 np->cur_tx, entry);
1041 }
1042 return NETDEV_TX_OK;
1043}
1044
1045static void netdev_tx_done(struct net_device *dev)
1046{
1047 struct netdev_private *np = netdev_priv(dev);
1048 for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1049 int entry = np->dirty_tx % TX_RING_SIZE;
1050 int tx_status = np->tx_ring[entry].status;
1051
1052 if (tx_status < 0)
1053 break;
1054 if (tx_status & 0x8000) {
1055#ifndef final_version
1056 if (debug > 1)
1057 netdev_dbg(dev, "Transmit error, Tx status %08x\n",
1058 tx_status);
1059#endif
1060 np->stats.tx_errors++;
1061 if (tx_status & 0x0104) np->stats.tx_aborted_errors++;
1062 if (tx_status & 0x0C80) np->stats.tx_carrier_errors++;
1063 if (tx_status & 0x0200) np->stats.tx_window_errors++;
1064 if (tx_status & 0x0002) np->stats.tx_fifo_errors++;
1065 if ((tx_status & 0x0080) && np->mii_if.full_duplex == 0)
1066 np->stats.tx_heartbeat_errors++;
1067 } else {
1068#ifndef final_version
1069 if (debug > 3)
1070 netdev_dbg(dev, "Transmit slot %d ok, Tx status %08x\n",
1071 entry, tx_status);
1072#endif
1073 np->stats.tx_bytes += np->tx_skbuff[entry]->len;
1074 np->stats.collisions += (tx_status >> 3) & 15;
1075 np->stats.tx_packets++;
1076 }
1077
1078 dma_unmap_single(&np->pci_dev->dev, np->tx_addr[entry],
1079 np->tx_skbuff[entry]->len, DMA_TO_DEVICE);
1080 np->tx_q_bytes -= np->tx_skbuff[entry]->len;
1081 dev_kfree_skb_irq(np->tx_skbuff[entry]);
1082 np->tx_skbuff[entry] = NULL;
1083 }
1084 if (np->tx_full &&
1085 np->cur_tx - np->dirty_tx < TX_QUEUE_LEN_RESTART &&
1086 np->tx_q_bytes < TX_BUG_FIFO_LIMIT) {
1087
1088 np->tx_full = 0;
1089 wmb();
1090 netif_wake_queue(dev);
1091 }
1092}
1093
1094
1095
1096static irqreturn_t intr_handler(int irq, void *dev_instance)
1097{
1098 struct net_device *dev = (struct net_device *)dev_instance;
1099 struct netdev_private *np = netdev_priv(dev);
1100 void __iomem *ioaddr = np->base_addr;
1101 int work_limit = max_interrupt_work;
1102 int handled = 0;
1103
1104 if (!netif_device_present(dev))
1105 return IRQ_NONE;
1106 do {
1107 u32 intr_status = ioread32(ioaddr + IntrStatus);
1108
1109
1110 iowrite32(intr_status & 0x001ffff, ioaddr + IntrStatus);
1111
1112 if (debug > 4)
1113 netdev_dbg(dev, "Interrupt, status %04x\n", intr_status);
1114
1115 if ((intr_status & (NormalIntr|AbnormalIntr)) == 0)
1116 break;
1117
1118 handled = 1;
1119
1120 if (intr_status & (RxIntr | RxNoBuf))
1121 netdev_rx(dev);
1122 if (intr_status & RxNoBuf)
1123 iowrite32(0, ioaddr + RxStartDemand);
1124
1125 if (intr_status & (TxNoBuf | TxIntr) &&
1126 np->cur_tx != np->dirty_tx) {
1127 spin_lock(&np->lock);
1128 netdev_tx_done(dev);
1129 spin_unlock(&np->lock);
1130 }
1131
1132
1133 if (intr_status & (AbnormalIntr | TxFIFOUnderflow | SystemError |
1134 TimerInt | TxDied))
1135 netdev_error(dev, intr_status);
1136
1137 if (--work_limit < 0) {
1138 dev_warn(&dev->dev,
1139 "Too much work at interrupt, status=0x%04x\n",
1140 intr_status);
1141
1142
1143 spin_lock(&np->lock);
1144 if (netif_device_present(dev)) {
1145 iowrite32(AbnormalIntr | TimerInt, ioaddr + IntrEnable);
1146 iowrite32(10, ioaddr + GPTimer);
1147 }
1148 spin_unlock(&np->lock);
1149 break;
1150 }
1151 } while (1);
1152
1153 if (debug > 3)
1154 netdev_dbg(dev, "exiting interrupt, status=%#4.4x\n",
1155 ioread32(ioaddr + IntrStatus));
1156 return IRQ_RETVAL(handled);
1157}
1158
1159
1160
1161static int netdev_rx(struct net_device *dev)
1162{
1163 struct netdev_private *np = netdev_priv(dev);
1164 int entry = np->cur_rx % RX_RING_SIZE;
1165 int work_limit = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
1166
1167 if (debug > 4) {
1168 netdev_dbg(dev, " In netdev_rx(), entry %d status %04x\n",
1169 entry, np->rx_ring[entry].status);
1170 }
1171
1172
1173 while (--work_limit >= 0) {
1174 struct w840_rx_desc *desc = np->rx_head_desc;
1175 s32 status = desc->status;
1176
1177 if (debug > 4)
1178 netdev_dbg(dev, " netdev_rx() status was %08x\n",
1179 status);
1180 if (status < 0)
1181 break;
1182 if ((status & 0x38008300) != 0x0300) {
1183 if ((status & 0x38000300) != 0x0300) {
1184
1185 if ((status & 0xffff) != 0x7fff) {
1186 dev_warn(&dev->dev,
1187 "Oversized Ethernet frame spanned multiple buffers, entry %#x status %04x!\n",
1188 np->cur_rx, status);
1189 np->stats.rx_length_errors++;
1190 }
1191 } else if (status & 0x8000) {
1192
1193 if (debug > 2)
1194 netdev_dbg(dev, "Receive error, Rx status %08x\n",
1195 status);
1196 np->stats.rx_errors++;
1197 if (status & 0x0890) np->stats.rx_length_errors++;
1198 if (status & 0x004C) np->stats.rx_frame_errors++;
1199 if (status & 0x0002) np->stats.rx_crc_errors++;
1200 }
1201 } else {
1202 struct sk_buff *skb;
1203
1204 int pkt_len = ((status >> 16) & 0x7ff) - 4;
1205
1206#ifndef final_version
1207 if (debug > 4)
1208 netdev_dbg(dev, " netdev_rx() normal Rx pkt length %d status %x\n",
1209 pkt_len, status);
1210#endif
1211
1212
1213 if (pkt_len < rx_copybreak &&
1214 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
1215 skb_reserve(skb, 2);
1216 dma_sync_single_for_cpu(&np->pci_dev->dev,
1217 np->rx_addr[entry],
1218 np->rx_skbuff[entry]->len,
1219 DMA_FROM_DEVICE);
1220 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1221 skb_put(skb, pkt_len);
1222 dma_sync_single_for_device(&np->pci_dev->dev,
1223 np->rx_addr[entry],
1224 np->rx_skbuff[entry]->len,
1225 DMA_FROM_DEVICE);
1226 } else {
1227 dma_unmap_single(&np->pci_dev->dev,
1228 np->rx_addr[entry],
1229 np->rx_skbuff[entry]->len,
1230 DMA_FROM_DEVICE);
1231 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1232 np->rx_skbuff[entry] = NULL;
1233 }
1234#ifndef final_version
1235
1236 if (debug > 5)
1237 netdev_dbg(dev, " Rx data %pM %pM %02x%02x %pI4\n",
1238 &skb->data[0], &skb->data[6],
1239 skb->data[12], skb->data[13],
1240 &skb->data[14]);
1241#endif
1242 skb->protocol = eth_type_trans(skb, dev);
1243 netif_rx(skb);
1244 np->stats.rx_packets++;
1245 np->stats.rx_bytes += pkt_len;
1246 }
1247 entry = (++np->cur_rx) % RX_RING_SIZE;
1248 np->rx_head_desc = &np->rx_ring[entry];
1249 }
1250
1251
1252 for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1253 struct sk_buff *skb;
1254 entry = np->dirty_rx % RX_RING_SIZE;
1255 if (np->rx_skbuff[entry] == NULL) {
1256 skb = netdev_alloc_skb(dev, np->rx_buf_sz);
1257 np->rx_skbuff[entry] = skb;
1258 if (skb == NULL)
1259 break;
1260 np->rx_addr[entry] = dma_map_single(&np->pci_dev->dev,
1261 skb->data,
1262 np->rx_buf_sz,
1263 DMA_FROM_DEVICE);
1264 np->rx_ring[entry].buffer1 = np->rx_addr[entry];
1265 }
1266 wmb();
1267 np->rx_ring[entry].status = DescOwned;
1268 }
1269
1270 return 0;
1271}
1272
1273static void netdev_error(struct net_device *dev, int intr_status)
1274{
1275 struct netdev_private *np = netdev_priv(dev);
1276 void __iomem *ioaddr = np->base_addr;
1277
1278 if (debug > 2)
1279 netdev_dbg(dev, "Abnormal event, %08x\n", intr_status);
1280 if (intr_status == 0xffffffff)
1281 return;
1282 spin_lock(&np->lock);
1283 if (intr_status & TxFIFOUnderflow) {
1284 int new;
1285
1286#if 0
1287
1288
1289
1290 new = np->csr6 + 0x4000;
1291#else
1292 new = (np->csr6 >> 14)&0x7f;
1293 if (new < 64)
1294 new *= 2;
1295 else
1296 new = 127;
1297 new = (np->csr6 & ~(0x7F << 14)) | (new<<14);
1298#endif
1299 netdev_dbg(dev, "Tx underflow, new csr6 %08x\n", new);
1300 update_csr6(dev, new);
1301 }
1302 if (intr_status & RxDied) {
1303 np->stats.rx_errors++;
1304 }
1305 if (intr_status & TimerInt) {
1306
1307 if (netif_device_present(dev))
1308 iowrite32(0x1A0F5, ioaddr + IntrEnable);
1309 }
1310 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1311 iowrite32(0, ioaddr + RxStartDemand);
1312 spin_unlock(&np->lock);
1313}
1314
1315static struct net_device_stats *get_stats(struct net_device *dev)
1316{
1317 struct netdev_private *np = netdev_priv(dev);
1318 void __iomem *ioaddr = np->base_addr;
1319
1320
1321 spin_lock_irq(&np->lock);
1322 if (netif_running(dev) && netif_device_present(dev))
1323 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1324 spin_unlock_irq(&np->lock);
1325
1326 return &np->stats;
1327}
1328
1329
1330static u32 __set_rx_mode(struct net_device *dev)
1331{
1332 struct netdev_private *np = netdev_priv(dev);
1333 void __iomem *ioaddr = np->base_addr;
1334 u32 mc_filter[2];
1335 u32 rx_mode;
1336
1337 if (dev->flags & IFF_PROMISC) {
1338 memset(mc_filter, 0xff, sizeof(mc_filter));
1339 rx_mode = RxAcceptBroadcast | AcceptMulticast | RxAcceptAllPhys
1340 | AcceptMyPhys;
1341 } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1342 (dev->flags & IFF_ALLMULTI)) {
1343
1344 memset(mc_filter, 0xff, sizeof(mc_filter));
1345 rx_mode = RxAcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1346 } else {
1347 struct netdev_hw_addr *ha;
1348
1349 memset(mc_filter, 0, sizeof(mc_filter));
1350 netdev_for_each_mc_addr(ha, dev) {
1351 int filbit;
1352
1353 filbit = (ether_crc(ETH_ALEN, ha->addr) >> 26) ^ 0x3F;
1354 filbit &= 0x3f;
1355 mc_filter[filbit >> 5] |= 1 << (filbit & 31);
1356 }
1357 rx_mode = RxAcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1358 }
1359 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1360 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1361 return rx_mode;
1362}
1363
1364static void set_rx_mode(struct net_device *dev)
1365{
1366 struct netdev_private *np = netdev_priv(dev);
1367 u32 rx_mode = __set_rx_mode(dev);
1368 spin_lock_irq(&np->lock);
1369 update_csr6(dev, (np->csr6 & ~0x00F8) | rx_mode);
1370 spin_unlock_irq(&np->lock);
1371}
1372
1373static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
1374{
1375 struct netdev_private *np = netdev_priv(dev);
1376
1377 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1378 strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1379}
1380
1381static int netdev_get_link_ksettings(struct net_device *dev,
1382 struct ethtool_link_ksettings *cmd)
1383{
1384 struct netdev_private *np = netdev_priv(dev);
1385
1386 spin_lock_irq(&np->lock);
1387 mii_ethtool_get_link_ksettings(&np->mii_if, cmd);
1388 spin_unlock_irq(&np->lock);
1389
1390 return 0;
1391}
1392
1393static int netdev_set_link_ksettings(struct net_device *dev,
1394 const struct ethtool_link_ksettings *cmd)
1395{
1396 struct netdev_private *np = netdev_priv(dev);
1397 int rc;
1398
1399 spin_lock_irq(&np->lock);
1400 rc = mii_ethtool_set_link_ksettings(&np->mii_if, cmd);
1401 spin_unlock_irq(&np->lock);
1402
1403 return rc;
1404}
1405
1406static int netdev_nway_reset(struct net_device *dev)
1407{
1408 struct netdev_private *np = netdev_priv(dev);
1409 return mii_nway_restart(&np->mii_if);
1410}
1411
1412static u32 netdev_get_link(struct net_device *dev)
1413{
1414 struct netdev_private *np = netdev_priv(dev);
1415 return mii_link_ok(&np->mii_if);
1416}
1417
1418static u32 netdev_get_msglevel(struct net_device *dev)
1419{
1420 return debug;
1421}
1422
1423static void netdev_set_msglevel(struct net_device *dev, u32 value)
1424{
1425 debug = value;
1426}
1427
1428static const struct ethtool_ops netdev_ethtool_ops = {
1429 .get_drvinfo = netdev_get_drvinfo,
1430 .nway_reset = netdev_nway_reset,
1431 .get_link = netdev_get_link,
1432 .get_msglevel = netdev_get_msglevel,
1433 .set_msglevel = netdev_set_msglevel,
1434 .get_link_ksettings = netdev_get_link_ksettings,
1435 .set_link_ksettings = netdev_set_link_ksettings,
1436};
1437
1438static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1439{
1440 struct mii_ioctl_data *data = if_mii(rq);
1441 struct netdev_private *np = netdev_priv(dev);
1442
1443 switch(cmd) {
1444 case SIOCGMIIPHY:
1445 data->phy_id = ((struct netdev_private *)netdev_priv(dev))->phys[0] & 0x1f;
1446 fallthrough;
1447
1448 case SIOCGMIIREG:
1449 spin_lock_irq(&np->lock);
1450 data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1451 spin_unlock_irq(&np->lock);
1452 return 0;
1453
1454 case SIOCSMIIREG:
1455 spin_lock_irq(&np->lock);
1456 mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1457 spin_unlock_irq(&np->lock);
1458 return 0;
1459 default:
1460 return -EOPNOTSUPP;
1461 }
1462}
1463
1464static int netdev_close(struct net_device *dev)
1465{
1466 struct netdev_private *np = netdev_priv(dev);
1467 void __iomem *ioaddr = np->base_addr;
1468
1469 netif_stop_queue(dev);
1470
1471 if (debug > 1) {
1472 netdev_dbg(dev, "Shutting down ethercard, status was %08x Config %08x\n",
1473 ioread32(ioaddr + IntrStatus),
1474 ioread32(ioaddr + NetworkConfig));
1475 netdev_dbg(dev, "Queue pointers were Tx %d / %d, Rx %d / %d\n",
1476 np->cur_tx, np->dirty_tx,
1477 np->cur_rx, np->dirty_rx);
1478 }
1479
1480
1481 spin_lock_irq(&np->lock);
1482 netif_device_detach(dev);
1483 update_csr6(dev, 0);
1484 iowrite32(0x0000, ioaddr + IntrEnable);
1485 spin_unlock_irq(&np->lock);
1486
1487 free_irq(np->pci_dev->irq, dev);
1488 wmb();
1489 netif_device_attach(dev);
1490
1491 if (ioread32(ioaddr + NetworkConfig) != 0xffffffff)
1492 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1493
1494#ifdef __i386__
1495 if (debug > 2) {
1496 int i;
1497
1498 printk(KERN_DEBUG" Tx ring at %p:\n", np->tx_ring);
1499 for (i = 0; i < TX_RING_SIZE; i++)
1500 printk(KERN_DEBUG " #%d desc. %04x %04x %08x\n",
1501 i, np->tx_ring[i].length,
1502 np->tx_ring[i].status, np->tx_ring[i].buffer1);
1503 printk(KERN_DEBUG " Rx ring %p:\n", np->rx_ring);
1504 for (i = 0; i < RX_RING_SIZE; i++) {
1505 printk(KERN_DEBUG " #%d desc. %04x %04x %08x\n",
1506 i, np->rx_ring[i].length,
1507 np->rx_ring[i].status, np->rx_ring[i].buffer1);
1508 }
1509 }
1510#endif
1511
1512 del_timer_sync(&np->timer);
1513
1514 free_rxtx_rings(np);
1515 free_ringdesc(np);
1516
1517 return 0;
1518}
1519
1520static void w840_remove1(struct pci_dev *pdev)
1521{
1522 struct net_device *dev = pci_get_drvdata(pdev);
1523
1524 if (dev) {
1525 struct netdev_private *np = netdev_priv(dev);
1526 unregister_netdev(dev);
1527 pci_iounmap(pdev, np->base_addr);
1528 free_netdev(dev);
1529 }
1530}
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555static int __maybe_unused w840_suspend(struct device *dev_d)
1556{
1557 struct net_device *dev = dev_get_drvdata(dev_d);
1558 struct netdev_private *np = netdev_priv(dev);
1559 void __iomem *ioaddr = np->base_addr;
1560
1561 rtnl_lock();
1562 if (netif_running (dev)) {
1563 del_timer_sync(&np->timer);
1564
1565 spin_lock_irq(&np->lock);
1566 netif_device_detach(dev);
1567 update_csr6(dev, 0);
1568 iowrite32(0, ioaddr + IntrEnable);
1569 spin_unlock_irq(&np->lock);
1570
1571 synchronize_irq(np->pci_dev->irq);
1572 netif_tx_disable(dev);
1573
1574 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1575
1576
1577
1578 BUG_ON(np->csr6 || ioread32(ioaddr + IntrEnable));
1579
1580
1581
1582 free_rxtx_rings(np);
1583 } else {
1584 netif_device_detach(dev);
1585 }
1586 rtnl_unlock();
1587 return 0;
1588}
1589
1590static int __maybe_unused w840_resume(struct device *dev_d)
1591{
1592 struct net_device *dev = dev_get_drvdata(dev_d);
1593 struct netdev_private *np = netdev_priv(dev);
1594
1595 rtnl_lock();
1596 if (netif_device_present(dev))
1597 goto out;
1598 if (netif_running(dev)) {
1599 spin_lock_irq(&np->lock);
1600 iowrite32(1, np->base_addr+PCIBusCfg);
1601 ioread32(np->base_addr+PCIBusCfg);
1602 udelay(1);
1603 netif_device_attach(dev);
1604 init_rxtx_rings(dev);
1605 init_registers(dev);
1606 spin_unlock_irq(&np->lock);
1607
1608 netif_wake_queue(dev);
1609
1610 mod_timer(&np->timer, jiffies + 1*HZ);
1611 } else {
1612 netif_device_attach(dev);
1613 }
1614out:
1615 rtnl_unlock();
1616 return 0;
1617}
1618
1619static SIMPLE_DEV_PM_OPS(w840_pm_ops, w840_suspend, w840_resume);
1620
1621static struct pci_driver w840_driver = {
1622 .name = DRV_NAME,
1623 .id_table = w840_pci_tbl,
1624 .probe = w840_probe1,
1625 .remove = w840_remove1,
1626 .driver.pm = &w840_pm_ops,
1627};
1628
1629module_pci_driver(w840_driver);
1630