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#define DRV_NAME "hamachi"
30#define DRV_VERSION "2.1"
31#define DRV_RELDATE "Sept 11, 2006"
32
33
34
35
36static int debug = 1;
37#define final_version
38#define hamachi_debug debug
39
40static int max_interrupt_work = 40;
41static int mtu;
42
43
44
45
46static int max_rx_latency = 0x11;
47static int max_rx_gap = 0x05;
48static int min_rx_pkt = 0x18;
49static int max_tx_latency = 0x00;
50static int max_tx_gap = 0x00;
51static int min_tx_pkt = 0x30;
52
53
54
55
56
57static int rx_copybreak;
58
59
60
61
62
63static int force32;
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85#define MAX_UNITS 8
86static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
87static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103static int rx_params[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
104static int tx_params[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119#define TX_RING_SIZE 64
120#define RX_RING_SIZE 512
121#define TX_TOTAL_SIZE TX_RING_SIZE*sizeof(struct hamachi_desc)
122#define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct hamachi_desc)
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137#define RX_CHECKSUM
138
139
140
141#define TX_TIMEOUT (5*HZ)
142
143#include <linux/capability.h>
144#include <linux/module.h>
145#include <linux/kernel.h>
146#include <linux/string.h>
147#include <linux/timer.h>
148#include <linux/time.h>
149#include <linux/errno.h>
150#include <linux/ioport.h>
151#include <linux/interrupt.h>
152#include <linux/pci.h>
153#include <linux/init.h>
154#include <linux/ethtool.h>
155#include <linux/mii.h>
156#include <linux/netdevice.h>
157#include <linux/etherdevice.h>
158#include <linux/skbuff.h>
159#include <linux/ip.h>
160#include <linux/delay.h>
161#include <linux/bitops.h>
162
163#include <linux/uaccess.h>
164#include <asm/processor.h>
165#include <asm/io.h>
166#include <asm/unaligned.h>
167#include <asm/cache.h>
168
169static const char version[] =
170KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n"
171" Some modifications by Eric kasten <kasten@nscl.msu.edu>\n"
172" Further modifications by Keith Underwood <keithu@parl.clemson.edu>\n";
173
174
175
176
177
178
179
180#ifndef IP_MF
181 #define IP_MF 0x2000
182#endif
183
184
185#ifndef IP_OFFSET
186 #ifdef IPOPT_OFFSET
187 #define IP_OFFSET IPOPT_OFFSET
188 #else
189 #define IP_OFFSET 2
190 #endif
191#endif
192
193#define RUN_AT(x) (jiffies + (x))
194
195#ifndef ADDRLEN
196#define ADDRLEN 32
197#endif
198
199
200#if ADDRLEN == 64
201#define cpu_to_leXX(addr) cpu_to_le64(addr)
202#define leXX_to_cpu(addr) le64_to_cpu(addr)
203#else
204#define cpu_to_leXX(addr) cpu_to_le32(addr)
205#define leXX_to_cpu(addr) le32_to_cpu(addr)
206#endif
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406#define PKT_BUF_SZ 1536
407
408
409
410
411
412#define MAX_FRAME_SIZE 1518
413
414
415
416static void hamachi_timer(struct timer_list *t);
417
418enum capability_flags {CanHaveMII=1, };
419static const struct chip_info {
420 u16 vendor_id, device_id, device_id_mask, pad;
421 const char *name;
422 void (*media_timer)(struct timer_list *t);
423 int flags;
424} chip_tbl[] = {
425 {0x1318, 0x0911, 0xffff, 0, "Hamachi GNIC-II", hamachi_timer, 0},
426 {0,},
427};
428
429
430enum hamachi_offsets {
431 TxDMACtrl=0x00, TxCmd=0x04, TxStatus=0x06, TxPtr=0x08, TxCurPtr=0x10,
432 RxDMACtrl=0x20, RxCmd=0x24, RxStatus=0x26, RxPtr=0x28, RxCurPtr=0x30,
433 PCIClkMeas=0x060, MiscStatus=0x066, ChipRev=0x68, ChipReset=0x06B,
434 LEDCtrl=0x06C, VirtualJumpers=0x06D, GPIO=0x6E,
435 TxChecksum=0x074, RxChecksum=0x076,
436 TxIntrCtrl=0x078, RxIntrCtrl=0x07C,
437 InterruptEnable=0x080, InterruptClear=0x084, IntrStatus=0x088,
438 EventStatus=0x08C,
439 MACCnfg=0x0A0, FrameGap0=0x0A2, FrameGap1=0x0A4,
440
441 MACCnfg2=0x0B0, RxDepth=0x0B8, FlowCtrl=0x0BC, MaxFrameSize=0x0CE,
442 AddrMode=0x0D0, StationAddr=0x0D2,
443
444 ANCtrl=0x0E0, ANStatus=0x0E2, ANXchngCtrl=0x0E4, ANAdvertise=0x0E8,
445 ANLinkPartnerAbility=0x0EA,
446 EECmdStatus=0x0F0, EEData=0x0F1, EEAddr=0x0F2,
447 FIFOcfg=0x0F8,
448};
449
450
451enum MII_offsets {
452 MII_Cmd=0xA6, MII_Addr=0xA8, MII_Wr_Data=0xAA, MII_Rd_Data=0xAC,
453 MII_Status=0xAE,
454};
455
456
457enum intr_status_bits {
458 IntrRxDone=0x01, IntrRxPCIFault=0x02, IntrRxPCIErr=0x04,
459 IntrTxDone=0x100, IntrTxPCIFault=0x200, IntrTxPCIErr=0x400,
460 LinkChange=0x10000, NegotiationChange=0x20000, StatsMax=0x40000, };
461
462
463struct hamachi_desc {
464 __le32 status_n_length;
465#if ADDRLEN == 64
466 u32 pad;
467 __le64 addr;
468#else
469 __le32 addr;
470#endif
471};
472
473
474enum desc_status_bits {
475 DescOwn=0x80000000, DescEndPacket=0x40000000, DescEndRing=0x20000000,
476 DescIntr=0x10000000,
477};
478
479#define PRIV_ALIGN 15
480#define MII_CNT 4
481struct hamachi_private {
482
483
484 struct hamachi_desc *rx_ring;
485 struct hamachi_desc *tx_ring;
486 struct sk_buff* rx_skbuff[RX_RING_SIZE];
487 struct sk_buff* tx_skbuff[TX_RING_SIZE];
488 dma_addr_t tx_ring_dma;
489 dma_addr_t rx_ring_dma;
490 struct timer_list timer;
491
492 spinlock_t lock;
493 int chip_id;
494 unsigned int cur_rx, dirty_rx;
495 unsigned int cur_tx, dirty_tx;
496 unsigned int rx_buf_sz;
497 unsigned int tx_full:1;
498 unsigned int duplex_lock:1;
499 unsigned int default_port:4;
500
501 int mii_cnt;
502 struct mii_if_info mii_if;
503 unsigned char phys[MII_CNT];
504 u32 rx_int_var, tx_int_var;
505 u32 option;
506 struct pci_dev *pci_dev;
507 void __iomem *base;
508};
509
510MODULE_AUTHOR("Donald Becker <becker@scyld.com>, Eric Kasten <kasten@nscl.msu.edu>, Keith Underwood <keithu@parl.clemson.edu>");
511MODULE_DESCRIPTION("Packet Engines 'Hamachi' GNIC-II Gigabit Ethernet driver");
512MODULE_LICENSE("GPL");
513
514module_param(max_interrupt_work, int, 0);
515module_param(mtu, int, 0);
516module_param(debug, int, 0);
517module_param(min_rx_pkt, int, 0);
518module_param(max_rx_gap, int, 0);
519module_param(max_rx_latency, int, 0);
520module_param(min_tx_pkt, int, 0);
521module_param(max_tx_gap, int, 0);
522module_param(max_tx_latency, int, 0);
523module_param(rx_copybreak, int, 0);
524module_param_array(rx_params, int, NULL, 0);
525module_param_array(tx_params, int, NULL, 0);
526module_param_array(options, int, NULL, 0);
527module_param_array(full_duplex, int, NULL, 0);
528module_param(force32, int, 0);
529MODULE_PARM_DESC(max_interrupt_work, "GNIC-II maximum events handled per interrupt");
530MODULE_PARM_DESC(mtu, "GNIC-II MTU (all boards)");
531MODULE_PARM_DESC(debug, "GNIC-II debug level (0-7)");
532MODULE_PARM_DESC(min_rx_pkt, "GNIC-II minimum Rx packets processed between interrupts");
533MODULE_PARM_DESC(max_rx_gap, "GNIC-II maximum Rx inter-packet gap in 8.192 microsecond units");
534MODULE_PARM_DESC(max_rx_latency, "GNIC-II time between Rx interrupts in 8.192 microsecond units");
535MODULE_PARM_DESC(min_tx_pkt, "GNIC-II minimum Tx packets processed between interrupts");
536MODULE_PARM_DESC(max_tx_gap, "GNIC-II maximum Tx inter-packet gap in 8.192 microsecond units");
537MODULE_PARM_DESC(max_tx_latency, "GNIC-II time between Tx interrupts in 8.192 microsecond units");
538MODULE_PARM_DESC(rx_copybreak, "GNIC-II copy breakpoint for copy-only-tiny-frames");
539MODULE_PARM_DESC(rx_params, "GNIC-II min_rx_pkt+max_rx_gap+max_rx_latency");
540MODULE_PARM_DESC(tx_params, "GNIC-II min_tx_pkt+max_tx_gap+max_tx_latency");
541MODULE_PARM_DESC(options, "GNIC-II Bits 0-3: media type, bits 4-6: as force32, bit 7: half duplex, bit 9 full duplex");
542MODULE_PARM_DESC(full_duplex, "GNIC-II full duplex setting(s) (1)");
543MODULE_PARM_DESC(force32, "GNIC-II: Bit 0: 32 bit PCI, bit 1: disable parity, bit 2: 64 bit PCI (all boards)");
544
545static int read_eeprom(void __iomem *ioaddr, int location);
546static int mdio_read(struct net_device *dev, int phy_id, int location);
547static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
548static int hamachi_open(struct net_device *dev);
549static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
550static void hamachi_timer(struct timer_list *t);
551static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue);
552static void hamachi_init_ring(struct net_device *dev);
553static netdev_tx_t hamachi_start_xmit(struct sk_buff *skb,
554 struct net_device *dev);
555static irqreturn_t hamachi_interrupt(int irq, void *dev_instance);
556static int hamachi_rx(struct net_device *dev);
557static inline int hamachi_tx(struct net_device *dev);
558static void hamachi_error(struct net_device *dev, int intr_status);
559static int hamachi_close(struct net_device *dev);
560static struct net_device_stats *hamachi_get_stats(struct net_device *dev);
561static void set_rx_mode(struct net_device *dev);
562static const struct ethtool_ops ethtool_ops;
563static const struct ethtool_ops ethtool_ops_no_mii;
564
565static const struct net_device_ops hamachi_netdev_ops = {
566 .ndo_open = hamachi_open,
567 .ndo_stop = hamachi_close,
568 .ndo_start_xmit = hamachi_start_xmit,
569 .ndo_get_stats = hamachi_get_stats,
570 .ndo_set_rx_mode = set_rx_mode,
571 .ndo_validate_addr = eth_validate_addr,
572 .ndo_set_mac_address = eth_mac_addr,
573 .ndo_tx_timeout = hamachi_tx_timeout,
574 .ndo_do_ioctl = netdev_ioctl,
575};
576
577
578static int hamachi_init_one(struct pci_dev *pdev,
579 const struct pci_device_id *ent)
580{
581 struct hamachi_private *hmp;
582 int option, i, rx_int_var, tx_int_var, boguscnt;
583 int chip_id = ent->driver_data;
584 int irq;
585 void __iomem *ioaddr;
586 unsigned long base;
587 static int card_idx;
588 struct net_device *dev;
589 void *ring_space;
590 dma_addr_t ring_dma;
591 int ret = -ENOMEM;
592
593
594#ifndef MODULE
595 static int printed_version;
596 if (!printed_version++)
597 printk(version);
598#endif
599
600 if (pci_enable_device(pdev)) {
601 ret = -EIO;
602 goto err_out;
603 }
604
605 base = pci_resource_start(pdev, 0);
606#ifdef __alpha__
607 base |= (pci_resource_start(pdev, 1) << 32);
608#endif
609
610 pci_set_master(pdev);
611
612 i = pci_request_regions(pdev, DRV_NAME);
613 if (i)
614 return i;
615
616 irq = pdev->irq;
617 ioaddr = ioremap(base, 0x400);
618 if (!ioaddr)
619 goto err_out_release;
620
621 dev = alloc_etherdev(sizeof(struct hamachi_private));
622 if (!dev)
623 goto err_out_iounmap;
624
625 SET_NETDEV_DEV(dev, &pdev->dev);
626
627 for (i = 0; i < 6; i++)
628 dev->dev_addr[i] = 1 ? read_eeprom(ioaddr, 4 + i)
629 : readb(ioaddr + StationAddr + i);
630
631#if ! defined(final_version)
632 if (hamachi_debug > 4)
633 for (i = 0; i < 0x10; i++)
634 printk("%2.2x%s",
635 read_eeprom(ioaddr, i), i % 16 != 15 ? " " : "\n");
636#endif
637
638 hmp = netdev_priv(dev);
639 spin_lock_init(&hmp->lock);
640
641 hmp->mii_if.dev = dev;
642 hmp->mii_if.mdio_read = mdio_read;
643 hmp->mii_if.mdio_write = mdio_write;
644 hmp->mii_if.phy_id_mask = 0x1f;
645 hmp->mii_if.reg_num_mask = 0x1f;
646
647 ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE, &ring_dma,
648 GFP_KERNEL);
649 if (!ring_space)
650 goto err_out_cleardev;
651 hmp->tx_ring = ring_space;
652 hmp->tx_ring_dma = ring_dma;
653
654 ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE, &ring_dma,
655 GFP_KERNEL);
656 if (!ring_space)
657 goto err_out_unmap_tx;
658 hmp->rx_ring = ring_space;
659 hmp->rx_ring_dma = ring_dma;
660
661
662 option = card_idx < MAX_UNITS ? options[card_idx] : 0;
663 if (dev->mem_start)
664 option = dev->mem_start;
665
666
667 force32 = force32 ? force32 :
668 ((option >= 0) ? ((option & 0x00000070) >> 4) : 0 );
669 if (force32)
670 writeb(force32, ioaddr + VirtualJumpers);
671
672
673 writeb(0x01, ioaddr + ChipReset);
674
675
676
677
678
679 udelay(10);
680 i = readb(ioaddr + PCIClkMeas);
681 for (boguscnt = 0; (!(i & 0x080)) && boguscnt < 1000; boguscnt++){
682 udelay(10);
683 i = readb(ioaddr + PCIClkMeas);
684 }
685
686 hmp->base = ioaddr;
687 pci_set_drvdata(pdev, dev);
688
689 hmp->chip_id = chip_id;
690 hmp->pci_dev = pdev;
691
692
693 if (option > 0) {
694 hmp->option = option;
695 if (option & 0x200)
696 hmp->mii_if.full_duplex = 1;
697 else if (option & 0x080)
698 hmp->mii_if.full_duplex = 0;
699 hmp->default_port = option & 15;
700 if (hmp->default_port)
701 hmp->mii_if.force_media = 1;
702 }
703 if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
704 hmp->mii_if.full_duplex = 1;
705
706
707 if (hmp->mii_if.full_duplex || (option & 0x080))
708 hmp->duplex_lock = 1;
709
710
711 max_rx_latency = max_rx_latency & 0x00ff;
712 max_rx_gap = max_rx_gap & 0x00ff;
713 min_rx_pkt = min_rx_pkt & 0x00ff;
714 max_tx_latency = max_tx_latency & 0x00ff;
715 max_tx_gap = max_tx_gap & 0x00ff;
716 min_tx_pkt = min_tx_pkt & 0x00ff;
717
718 rx_int_var = card_idx < MAX_UNITS ? rx_params[card_idx] : -1;
719 tx_int_var = card_idx < MAX_UNITS ? tx_params[card_idx] : -1;
720 hmp->rx_int_var = rx_int_var >= 0 ? rx_int_var :
721 (min_rx_pkt << 16 | max_rx_gap << 8 | max_rx_latency);
722 hmp->tx_int_var = tx_int_var >= 0 ? tx_int_var :
723 (min_tx_pkt << 16 | max_tx_gap << 8 | max_tx_latency);
724
725
726
727 dev->netdev_ops = &hamachi_netdev_ops;
728 dev->ethtool_ops = (chip_tbl[hmp->chip_id].flags & CanHaveMII) ?
729 ðtool_ops : ðtool_ops_no_mii;
730 dev->watchdog_timeo = TX_TIMEOUT;
731 if (mtu)
732 dev->mtu = mtu;
733
734 i = register_netdev(dev);
735 if (i) {
736 ret = i;
737 goto err_out_unmap_rx;
738 }
739
740 printk(KERN_INFO "%s: %s type %x at %p, %pM, IRQ %d.\n",
741 dev->name, chip_tbl[chip_id].name, readl(ioaddr + ChipRev),
742 ioaddr, dev->dev_addr, irq);
743 i = readb(ioaddr + PCIClkMeas);
744 printk(KERN_INFO "%s: %d-bit %d Mhz PCI bus (%d), Virtual Jumpers "
745 "%2.2x, LPA %4.4x.\n",
746 dev->name, readw(ioaddr + MiscStatus) & 1 ? 64 : 32,
747 i ? 2000/(i&0x7f) : 0, i&0x7f, (int)readb(ioaddr + VirtualJumpers),
748 readw(ioaddr + ANLinkPartnerAbility));
749
750 if (chip_tbl[hmp->chip_id].flags & CanHaveMII) {
751 int phy, phy_idx = 0;
752 for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {
753 int mii_status = mdio_read(dev, phy, MII_BMSR);
754 if (mii_status != 0xffff &&
755 mii_status != 0x0000) {
756 hmp->phys[phy_idx++] = phy;
757 hmp->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
758 printk(KERN_INFO "%s: MII PHY found at address %d, status "
759 "0x%4.4x advertising %4.4x.\n",
760 dev->name, phy, mii_status, hmp->mii_if.advertising);
761 }
762 }
763 hmp->mii_cnt = phy_idx;
764 if (hmp->mii_cnt > 0)
765 hmp->mii_if.phy_id = hmp->phys[0];
766 else
767 memset(&hmp->mii_if, 0, sizeof(hmp->mii_if));
768 }
769
770 writew(0x0400, ioaddr + ANXchngCtrl);
771 writew(0x08e0, ioaddr + ANAdvertise);
772 writew(0x1000, ioaddr + ANCtrl);
773
774 card_idx++;
775 return 0;
776
777err_out_unmap_rx:
778 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
779 hmp->rx_ring_dma);
780err_out_unmap_tx:
781 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
782 hmp->tx_ring_dma);
783err_out_cleardev:
784 free_netdev (dev);
785err_out_iounmap:
786 iounmap(ioaddr);
787err_out_release:
788 pci_release_regions(pdev);
789err_out:
790 return ret;
791}
792
793static int read_eeprom(void __iomem *ioaddr, int location)
794{
795 int bogus_cnt = 1000;
796
797
798 while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);
799 writew(location, ioaddr + EEAddr);
800 writeb(0x02, ioaddr + EECmdStatus);
801 bogus_cnt = 1000;
802 while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);
803 if (hamachi_debug > 5)
804 printk(" EEPROM status is %2.2x after %d ticks.\n",
805 (int)readb(ioaddr + EECmdStatus), 1000- bogus_cnt);
806 return readb(ioaddr + EEData);
807}
808
809
810
811
812
813static int mdio_read(struct net_device *dev, int phy_id, int location)
814{
815 struct hamachi_private *hmp = netdev_priv(dev);
816 void __iomem *ioaddr = hmp->base;
817 int i;
818
819
820 for (i = 10000; i >= 0; i--)
821 if ((readw(ioaddr + MII_Status) & 1) == 0)
822 break;
823 writew((phy_id<<8) + location, ioaddr + MII_Addr);
824 writew(0x0001, ioaddr + MII_Cmd);
825 for (i = 10000; i >= 0; i--)
826 if ((readw(ioaddr + MII_Status) & 1) == 0)
827 break;
828 return readw(ioaddr + MII_Rd_Data);
829}
830
831static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
832{
833 struct hamachi_private *hmp = netdev_priv(dev);
834 void __iomem *ioaddr = hmp->base;
835 int i;
836
837
838 for (i = 10000; i >= 0; i--)
839 if ((readw(ioaddr + MII_Status) & 1) == 0)
840 break;
841 writew((phy_id<<8) + location, ioaddr + MII_Addr);
842 writew(value, ioaddr + MII_Wr_Data);
843
844
845 for (i = 10000; i >= 0; i--)
846 if ((readw(ioaddr + MII_Status) & 1) == 0)
847 break;
848}
849
850
851static int hamachi_open(struct net_device *dev)
852{
853 struct hamachi_private *hmp = netdev_priv(dev);
854 void __iomem *ioaddr = hmp->base;
855 int i;
856 u32 rx_int_var, tx_int_var;
857 u16 fifo_info;
858
859 i = request_irq(hmp->pci_dev->irq, hamachi_interrupt, IRQF_SHARED,
860 dev->name, dev);
861 if (i)
862 return i;
863
864 hamachi_init_ring(dev);
865
866#if ADDRLEN == 64
867
868 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
869 writel(hmp->rx_ring_dma >> 32, ioaddr + RxPtr + 4);
870 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
871 writel(hmp->tx_ring_dma >> 32, ioaddr + TxPtr + 4);
872#else
873 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
874 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
875#endif
876
877
878
879
880 for (i = 0; i < 6; i++)
881 writeb(dev->dev_addr[i], ioaddr + StationAddr + i);
882
883
884
885
886
887 fifo_info = (readw(ioaddr + GPIO) & 0x00C0) >> 6;
888 switch (fifo_info){
889 case 0 :
890
891 writew(0x0000, ioaddr + FIFOcfg);
892 break;
893 case 1 :
894
895 writew(0x0028, ioaddr + FIFOcfg);
896 break;
897 case 2 :
898
899 writew(0x004C, ioaddr + FIFOcfg);
900 break;
901 case 3 :
902
903 writew(0x006C, ioaddr + FIFOcfg);
904 break;
905 default :
906 printk(KERN_WARNING "%s: Unsupported external memory config!\n",
907 dev->name);
908
909 writew(0x0000, ioaddr + FIFOcfg);
910 break;
911 }
912
913 if (dev->if_port == 0)
914 dev->if_port = hmp->default_port;
915
916
917
918
919 if (hmp->duplex_lock != 1)
920 hmp->mii_if.full_duplex = 1;
921
922
923 writew(0x0001, ioaddr + RxChecksum);
924 writew(0x0000, ioaddr + TxChecksum);
925 writew(0x8000, ioaddr + MACCnfg);
926 writew(0x215F, ioaddr + MACCnfg);
927 writew(0x000C, ioaddr + FrameGap0);
928
929 writew(0x1018, ioaddr + FrameGap1);
930
931 writew(0x0780, ioaddr + MACCnfg2);
932
933 writel(0x0030FFFF, ioaddr + FlowCtrl);
934 writew(MAX_FRAME_SIZE, ioaddr + MaxFrameSize);
935
936
937 writew(0x0400, ioaddr + ANXchngCtrl);
938
939 writeb(0x03, ioaddr + LEDCtrl);
940
941
942
943
944 rx_int_var = hmp->rx_int_var;
945 tx_int_var = hmp->tx_int_var;
946
947 if (hamachi_debug > 1) {
948 printk("max_tx_latency: %d, max_tx_gap: %d, min_tx_pkt: %d\n",
949 tx_int_var & 0x00ff, (tx_int_var & 0x00ff00) >> 8,
950 (tx_int_var & 0x00ff0000) >> 16);
951 printk("max_rx_latency: %d, max_rx_gap: %d, min_rx_pkt: %d\n",
952 rx_int_var & 0x00ff, (rx_int_var & 0x00ff00) >> 8,
953 (rx_int_var & 0x00ff0000) >> 16);
954 printk("rx_int_var: %x, tx_int_var: %x\n", rx_int_var, tx_int_var);
955 }
956
957 writel(tx_int_var, ioaddr + TxIntrCtrl);
958 writel(rx_int_var, ioaddr + RxIntrCtrl);
959
960 set_rx_mode(dev);
961
962 netif_start_queue(dev);
963
964
965 writel(0x80878787, ioaddr + InterruptEnable);
966 writew(0x0000, ioaddr + EventStatus);
967
968
969
970#if ADDRLEN == 64
971 writew(0x005D, ioaddr + RxDMACtrl);
972 writew(0x005D, ioaddr + TxDMACtrl);
973#else
974 writew(0x001D, ioaddr + RxDMACtrl);
975 writew(0x001D, ioaddr + TxDMACtrl);
976#endif
977 writew(0x0001, ioaddr + RxCmd);
978
979 if (hamachi_debug > 2) {
980 printk(KERN_DEBUG "%s: Done hamachi_open(), status: Rx %x Tx %x.\n",
981 dev->name, readw(ioaddr + RxStatus), readw(ioaddr + TxStatus));
982 }
983
984 timer_setup(&hmp->timer, hamachi_timer, 0);
985 hmp->timer.expires = RUN_AT((24*HZ)/10);
986 add_timer(&hmp->timer);
987
988 return 0;
989}
990
991static inline int hamachi_tx(struct net_device *dev)
992{
993 struct hamachi_private *hmp = netdev_priv(dev);
994
995
996
997 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++) {
998 int entry = hmp->dirty_tx % TX_RING_SIZE;
999 struct sk_buff *skb;
1000
1001 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1002 break;
1003
1004 skb = hmp->tx_skbuff[entry];
1005 if (skb) {
1006 dma_unmap_single(&hmp->pci_dev->dev,
1007 leXX_to_cpu(hmp->tx_ring[entry].addr),
1008 skb->len, DMA_TO_DEVICE);
1009 dev_kfree_skb(skb);
1010 hmp->tx_skbuff[entry] = NULL;
1011 }
1012 hmp->tx_ring[entry].status_n_length = 0;
1013 if (entry >= TX_RING_SIZE-1)
1014 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1015 cpu_to_le32(DescEndRing);
1016 dev->stats.tx_packets++;
1017 }
1018
1019 return 0;
1020}
1021
1022static void hamachi_timer(struct timer_list *t)
1023{
1024 struct hamachi_private *hmp = from_timer(hmp, t, timer);
1025 struct net_device *dev = hmp->mii_if.dev;
1026 void __iomem *ioaddr = hmp->base;
1027 int next_tick = 10*HZ;
1028
1029 if (hamachi_debug > 2) {
1030 printk(KERN_INFO "%s: Hamachi Autonegotiation status %4.4x, LPA "
1031 "%4.4x.\n", dev->name, readw(ioaddr + ANStatus),
1032 readw(ioaddr + ANLinkPartnerAbility));
1033 printk(KERN_INFO "%s: Autonegotiation regs %4.4x %4.4x %4.4x "
1034 "%4.4x %4.4x %4.4x.\n", dev->name,
1035 readw(ioaddr + 0x0e0),
1036 readw(ioaddr + 0x0e2),
1037 readw(ioaddr + 0x0e4),
1038 readw(ioaddr + 0x0e6),
1039 readw(ioaddr + 0x0e8),
1040 readw(ioaddr + 0x0eA));
1041 }
1042
1043 hmp->timer.expires = RUN_AT(next_tick);
1044 add_timer(&hmp->timer);
1045}
1046
1047static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue)
1048{
1049 int i;
1050 struct hamachi_private *hmp = netdev_priv(dev);
1051 void __iomem *ioaddr = hmp->base;
1052
1053 printk(KERN_WARNING "%s: Hamachi transmit timed out, status %8.8x,"
1054 " resetting...\n", dev->name, (int)readw(ioaddr + TxStatus));
1055
1056 {
1057 printk(KERN_DEBUG " Rx ring %p: ", hmp->rx_ring);
1058 for (i = 0; i < RX_RING_SIZE; i++)
1059 printk(KERN_CONT " %8.8x",
1060 le32_to_cpu(hmp->rx_ring[i].status_n_length));
1061 printk(KERN_CONT "\n");
1062 printk(KERN_DEBUG" Tx ring %p: ", hmp->tx_ring);
1063 for (i = 0; i < TX_RING_SIZE; i++)
1064 printk(KERN_CONT " %4.4x",
1065 le32_to_cpu(hmp->tx_ring[i].status_n_length));
1066 printk(KERN_CONT "\n");
1067 }
1068
1069
1070
1071
1072 dev->if_port = 0;
1073
1074
1075
1076
1077
1078
1079
1080 for (i = 0; i < RX_RING_SIZE; i++)
1081 hmp->rx_ring[i].status_n_length &= cpu_to_le32(~DescOwn);
1082
1083
1084
1085
1086 for (i = 0; i < TX_RING_SIZE; i++){
1087 struct sk_buff *skb;
1088
1089 if (i >= TX_RING_SIZE - 1)
1090 hmp->tx_ring[i].status_n_length =
1091 cpu_to_le32(DescEndRing) |
1092 (hmp->tx_ring[i].status_n_length &
1093 cpu_to_le32(0x0000ffff));
1094 else
1095 hmp->tx_ring[i].status_n_length &= cpu_to_le32(0x0000ffff);
1096 skb = hmp->tx_skbuff[i];
1097 if (skb){
1098 dma_unmap_single(&hmp->pci_dev->dev,
1099 leXX_to_cpu(hmp->tx_ring[i].addr),
1100 skb->len, DMA_TO_DEVICE);
1101 dev_kfree_skb(skb);
1102 hmp->tx_skbuff[i] = NULL;
1103 }
1104 }
1105
1106 udelay(60);
1107 writew(0x0002, ioaddr + RxCmd);
1108
1109 writeb(0x01, ioaddr + ChipReset);
1110
1111 hmp->tx_full = 0;
1112 hmp->cur_rx = hmp->cur_tx = 0;
1113 hmp->dirty_rx = hmp->dirty_tx = 0;
1114
1115
1116
1117 for (i = 0; i < RX_RING_SIZE; i++){
1118 struct sk_buff *skb = hmp->rx_skbuff[i];
1119
1120 if (skb){
1121 dma_unmap_single(&hmp->pci_dev->dev,
1122 leXX_to_cpu(hmp->rx_ring[i].addr),
1123 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1124 dev_kfree_skb(skb);
1125 hmp->rx_skbuff[i] = NULL;
1126 }
1127 }
1128
1129 for (i = 0; i < RX_RING_SIZE; i++) {
1130 struct sk_buff *skb;
1131
1132 skb = netdev_alloc_skb_ip_align(dev, hmp->rx_buf_sz);
1133 hmp->rx_skbuff[i] = skb;
1134 if (skb == NULL)
1135 break;
1136
1137 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1138 skb->data,
1139 hmp->rx_buf_sz,
1140 DMA_FROM_DEVICE));
1141 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1142 DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));
1143 }
1144 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1145
1146 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1147
1148
1149 netif_trans_update(dev);
1150 dev->stats.tx_errors++;
1151
1152
1153 writew(0x0002, ioaddr + TxCmd);
1154 writew(0x0001, ioaddr + TxCmd);
1155 writew(0x0001, ioaddr + RxCmd);
1156
1157 netif_wake_queue(dev);
1158}
1159
1160
1161
1162static void hamachi_init_ring(struct net_device *dev)
1163{
1164 struct hamachi_private *hmp = netdev_priv(dev);
1165 int i;
1166
1167 hmp->tx_full = 0;
1168 hmp->cur_rx = hmp->cur_tx = 0;
1169 hmp->dirty_rx = hmp->dirty_tx = 0;
1170
1171
1172
1173
1174
1175
1176 hmp->rx_buf_sz = (dev->mtu <= 1492 ? PKT_BUF_SZ :
1177 (((dev->mtu+26+7) & ~7) + 16));
1178
1179
1180 for (i = 0; i < RX_RING_SIZE; i++) {
1181 hmp->rx_ring[i].status_n_length = 0;
1182 hmp->rx_skbuff[i] = NULL;
1183 }
1184
1185 for (i = 0; i < RX_RING_SIZE; i++) {
1186 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1187 hmp->rx_skbuff[i] = skb;
1188 if (skb == NULL)
1189 break;
1190 skb_reserve(skb, 2);
1191 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1192 skb->data,
1193 hmp->rx_buf_sz,
1194 DMA_FROM_DEVICE));
1195
1196 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1197 DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));
1198 }
1199 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1200 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1201
1202 for (i = 0; i < TX_RING_SIZE; i++) {
1203 hmp->tx_skbuff[i] = NULL;
1204 hmp->tx_ring[i].status_n_length = 0;
1205 }
1206
1207 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1208}
1209
1210
1211static netdev_tx_t hamachi_start_xmit(struct sk_buff *skb,
1212 struct net_device *dev)
1213{
1214 struct hamachi_private *hmp = netdev_priv(dev);
1215 unsigned entry;
1216 u16 status;
1217
1218
1219
1220
1221
1222
1223 if (hmp->tx_full) {
1224
1225 printk(KERN_WARNING "%s: Hamachi transmit queue full at slot %d.\n",dev->name, hmp->cur_tx);
1226
1227
1228
1229 status=readw(hmp->base + TxStatus);
1230 if( !(status & 0x0001) || (status & 0x0002))
1231 writew(0x0001, hmp->base + TxCmd);
1232 return NETDEV_TX_BUSY;
1233 }
1234
1235
1236
1237
1238
1239 entry = hmp->cur_tx % TX_RING_SIZE;
1240
1241 hmp->tx_skbuff[entry] = skb;
1242
1243 hmp->tx_ring[entry].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1244 skb->data,
1245 skb->len,
1246 DMA_TO_DEVICE));
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257 if (entry >= TX_RING_SIZE-1)
1258 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1259 DescEndPacket | DescEndRing | DescIntr | skb->len);
1260 else
1261 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1262 DescEndPacket | DescIntr | skb->len);
1263 hmp->cur_tx++;
1264
1265
1266
1267
1268
1269 status=readw(hmp->base + TxStatus);
1270 if( !(status & 0x0001) || (status & 0x0002))
1271 writew(0x0001, hmp->base + TxCmd);
1272
1273
1274 hamachi_tx(dev);
1275
1276
1277
1278
1279
1280
1281
1282 if ((hmp->cur_tx - hmp->dirty_tx) < (TX_RING_SIZE - 4))
1283 netif_wake_queue(dev);
1284 else {
1285 hmp->tx_full = 1;
1286 netif_stop_queue(dev);
1287 }
1288
1289 if (hamachi_debug > 4) {
1290 printk(KERN_DEBUG "%s: Hamachi transmit frame #%d queued in slot %d.\n",
1291 dev->name, hmp->cur_tx, entry);
1292 }
1293 return NETDEV_TX_OK;
1294}
1295
1296
1297
1298static irqreturn_t hamachi_interrupt(int irq, void *dev_instance)
1299{
1300 struct net_device *dev = dev_instance;
1301 struct hamachi_private *hmp = netdev_priv(dev);
1302 void __iomem *ioaddr = hmp->base;
1303 long boguscnt = max_interrupt_work;
1304 int handled = 0;
1305
1306#ifndef final_version
1307 if (dev == NULL) {
1308 printk (KERN_ERR "hamachi_interrupt(): irq %d for unknown device.\n", irq);
1309 return IRQ_NONE;
1310 }
1311#endif
1312
1313 spin_lock(&hmp->lock);
1314
1315 do {
1316 u32 intr_status = readl(ioaddr + InterruptClear);
1317
1318 if (hamachi_debug > 4)
1319 printk(KERN_DEBUG "%s: Hamachi interrupt, status %4.4x.\n",
1320 dev->name, intr_status);
1321
1322 if (intr_status == 0)
1323 break;
1324
1325 handled = 1;
1326
1327 if (intr_status & IntrRxDone)
1328 hamachi_rx(dev);
1329
1330 if (intr_status & IntrTxDone){
1331
1332
1333
1334
1335 if (hmp->tx_full){
1336 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++){
1337 int entry = hmp->dirty_tx % TX_RING_SIZE;
1338 struct sk_buff *skb;
1339
1340 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1341 break;
1342 skb = hmp->tx_skbuff[entry];
1343
1344 if (skb){
1345 dma_unmap_single(&hmp->pci_dev->dev,
1346 leXX_to_cpu(hmp->tx_ring[entry].addr),
1347 skb->len,
1348 DMA_TO_DEVICE);
1349 dev_consume_skb_irq(skb);
1350 hmp->tx_skbuff[entry] = NULL;
1351 }
1352 hmp->tx_ring[entry].status_n_length = 0;
1353 if (entry >= TX_RING_SIZE-1)
1354 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1355 cpu_to_le32(DescEndRing);
1356 dev->stats.tx_packets++;
1357 }
1358 if (hmp->cur_tx - hmp->dirty_tx < TX_RING_SIZE - 4){
1359
1360 hmp->tx_full = 0;
1361 netif_wake_queue(dev);
1362 }
1363 } else {
1364 netif_wake_queue(dev);
1365 }
1366 }
1367
1368
1369
1370 if (intr_status &
1371 (IntrTxPCIFault | IntrTxPCIErr | IntrRxPCIFault | IntrRxPCIErr |
1372 LinkChange | NegotiationChange | StatsMax))
1373 hamachi_error(dev, intr_status);
1374
1375 if (--boguscnt < 0) {
1376 printk(KERN_WARNING "%s: Too much work at interrupt, status=0x%4.4x.\n",
1377 dev->name, intr_status);
1378 break;
1379 }
1380 } while (1);
1381
1382 if (hamachi_debug > 3)
1383 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1384 dev->name, readl(ioaddr + IntrStatus));
1385
1386#ifndef final_version
1387
1388 {
1389 static int stopit = 10;
1390 if (dev->start == 0 && --stopit < 0) {
1391 printk(KERN_ERR "%s: Emergency stop, looping startup interrupt.\n",
1392 dev->name);
1393 free_irq(irq, dev);
1394 }
1395 }
1396#endif
1397
1398 spin_unlock(&hmp->lock);
1399 return IRQ_RETVAL(handled);
1400}
1401
1402
1403
1404static int hamachi_rx(struct net_device *dev)
1405{
1406 struct hamachi_private *hmp = netdev_priv(dev);
1407 int entry = hmp->cur_rx % RX_RING_SIZE;
1408 int boguscnt = (hmp->dirty_rx + RX_RING_SIZE) - hmp->cur_rx;
1409
1410 if (hamachi_debug > 4) {
1411 printk(KERN_DEBUG " In hamachi_rx(), entry %d status %4.4x.\n",
1412 entry, hmp->rx_ring[entry].status_n_length);
1413 }
1414
1415
1416 while (1) {
1417 struct hamachi_desc *desc = &(hmp->rx_ring[entry]);
1418 u32 desc_status = le32_to_cpu(desc->status_n_length);
1419 u16 data_size = desc_status;
1420 u8 *buf_addr;
1421 s32 frame_status;
1422
1423 if (desc_status & DescOwn)
1424 break;
1425 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1426 leXX_to_cpu(desc->addr),
1427 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1428 buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
1429 frame_status = get_unaligned_le32(&(buf_addr[data_size - 12]));
1430 if (hamachi_debug > 4)
1431 printk(KERN_DEBUG " hamachi_rx() status was %8.8x.\n",
1432 frame_status);
1433 if (--boguscnt < 0)
1434 break;
1435 if ( ! (desc_status & DescEndPacket)) {
1436 printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "
1437 "multiple buffers, entry %#x length %d status %4.4x!\n",
1438 dev->name, hmp->cur_rx, data_size, desc_status);
1439 printk(KERN_WARNING "%s: Oversized Ethernet frame %p vs %p.\n",
1440 dev->name, desc, &hmp->rx_ring[hmp->cur_rx % RX_RING_SIZE]);
1441 printk(KERN_WARNING "%s: Oversized Ethernet frame -- next status %x/%x last status %x.\n",
1442 dev->name,
1443 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0xffff0000,
1444 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0x0000ffff,
1445 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length));
1446 dev->stats.rx_length_errors++;
1447 }
1448 if (frame_status & 0x00380000) {
1449
1450 if (hamachi_debug > 2)
1451 printk(KERN_DEBUG " hamachi_rx() Rx error was %8.8x.\n",
1452 frame_status);
1453 dev->stats.rx_errors++;
1454 if (frame_status & 0x00600000)
1455 dev->stats.rx_length_errors++;
1456 if (frame_status & 0x00080000)
1457 dev->stats.rx_frame_errors++;
1458 if (frame_status & 0x00100000)
1459 dev->stats.rx_crc_errors++;
1460 if (frame_status < 0)
1461 dev->stats.rx_dropped++;
1462 } else {
1463 struct sk_buff *skb;
1464
1465 u16 pkt_len = (frame_status & 0x07ff) - 4;
1466#ifdef RX_CHECKSUM
1467 u32 pfck = *(u32 *) &buf_addr[data_size - 8];
1468#endif
1469
1470
1471#ifndef final_version
1472 if (hamachi_debug > 4)
1473 printk(KERN_DEBUG " hamachi_rx() normal Rx pkt length %d"
1474 " of %d, bogus_cnt %d.\n",
1475 pkt_len, data_size, boguscnt);
1476 if (hamachi_debug > 5)
1477 printk(KERN_DEBUG"%s: rx status %8.8x %8.8x %8.8x %8.8x %8.8x.\n",
1478 dev->name,
1479 *(s32*)&(buf_addr[data_size - 20]),
1480 *(s32*)&(buf_addr[data_size - 16]),
1481 *(s32*)&(buf_addr[data_size - 12]),
1482 *(s32*)&(buf_addr[data_size - 8]),
1483 *(s32*)&(buf_addr[data_size - 4]));
1484#endif
1485
1486
1487 if (pkt_len < rx_copybreak &&
1488 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
1489#ifdef RX_CHECKSUM
1490 printk(KERN_ERR "%s: rx_copybreak non-zero "
1491 "not good with RX_CHECKSUM\n", dev->name);
1492#endif
1493 skb_reserve(skb, 2);
1494 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1495 leXX_to_cpu(hmp->rx_ring[entry].addr),
1496 hmp->rx_buf_sz,
1497 DMA_FROM_DEVICE);
1498
1499#if 1 || USE_IP_COPYSUM
1500 skb_copy_to_linear_data(skb,
1501 hmp->rx_skbuff[entry]->data, pkt_len);
1502 skb_put(skb, pkt_len);
1503#else
1504 skb_put_data(skb, hmp->rx_ring_dma
1505 + entry*sizeof(*desc), pkt_len);
1506#endif
1507 dma_sync_single_for_device(&hmp->pci_dev->dev,
1508 leXX_to_cpu(hmp->rx_ring[entry].addr),
1509 hmp->rx_buf_sz,
1510 DMA_FROM_DEVICE);
1511 } else {
1512 dma_unmap_single(&hmp->pci_dev->dev,
1513 leXX_to_cpu(hmp->rx_ring[entry].addr),
1514 hmp->rx_buf_sz,
1515 DMA_FROM_DEVICE);
1516 skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
1517 hmp->rx_skbuff[entry] = NULL;
1518 }
1519 skb->protocol = eth_type_trans(skb, dev);
1520
1521
1522#ifdef RX_CHECKSUM
1523
1524 if (pfck>>24 == 0x91 || pfck>>24 == 0x51) {
1525 struct iphdr *ih = (struct iphdr *) skb->data;
1526
1527
1528
1529
1530 if (ntohs(ih->tot_len) >= 46){
1531
1532 if (!(ih->frag_off & cpu_to_be16(IP_MF|IP_OFFSET))) {
1533 u32 inv = *(u32 *) &buf_addr[data_size - 16];
1534 u32 *p = (u32 *) &buf_addr[data_size - 20];
1535 register u32 crc, p_r, p_r1;
1536
1537 if (inv & 4) {
1538 inv &= ~4;
1539 --p;
1540 }
1541 p_r = *p;
1542 p_r1 = *(p-1);
1543 switch (inv) {
1544 case 0:
1545 crc = (p_r & 0xffff) + (p_r >> 16);
1546 break;
1547 case 1:
1548 crc = (p_r >> 16) + (p_r & 0xffff)
1549 + (p_r1 >> 16 & 0xff00);
1550 break;
1551 case 2:
1552 crc = p_r + (p_r1 >> 16);
1553 break;
1554 case 3:
1555 crc = p_r + (p_r1 & 0xff00) + (p_r1 >> 16);
1556 break;
1557 default: crc = 0;
1558 }
1559 if (crc & 0xffff0000) {
1560 crc &= 0xffff;
1561 ++crc;
1562 }
1563
1564 skb->csum = ntohs(pfck & 0xffff);
1565 if (skb->csum > crc)
1566 skb->csum -= crc;
1567 else
1568 skb->csum += (~crc & 0xffff);
1569
1570
1571
1572
1573 skb->ip_summed = CHECKSUM_COMPLETE;
1574 }
1575 }
1576 }
1577#endif
1578
1579 netif_rx(skb);
1580 dev->stats.rx_packets++;
1581 }
1582 entry = (++hmp->cur_rx) % RX_RING_SIZE;
1583 }
1584
1585
1586 for (; hmp->cur_rx - hmp->dirty_rx > 0; hmp->dirty_rx++) {
1587 struct hamachi_desc *desc;
1588
1589 entry = hmp->dirty_rx % RX_RING_SIZE;
1590 desc = &(hmp->rx_ring[entry]);
1591 if (hmp->rx_skbuff[entry] == NULL) {
1592 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1593
1594 hmp->rx_skbuff[entry] = skb;
1595 if (skb == NULL)
1596 break;
1597 skb_reserve(skb, 2);
1598 desc->addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1599 skb->data,
1600 hmp->rx_buf_sz,
1601 DMA_FROM_DEVICE));
1602 }
1603 desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);
1604 if (entry >= RX_RING_SIZE-1)
1605 desc->status_n_length |= cpu_to_le32(DescOwn |
1606 DescEndPacket | DescEndRing | DescIntr);
1607 else
1608 desc->status_n_length |= cpu_to_le32(DescOwn |
1609 DescEndPacket | DescIntr);
1610 }
1611
1612
1613
1614 if (readw(hmp->base + RxStatus) & 0x0002)
1615 writew(0x0001, hmp->base + RxCmd);
1616
1617 return 0;
1618}
1619
1620
1621
1622static void hamachi_error(struct net_device *dev, int intr_status)
1623{
1624 struct hamachi_private *hmp = netdev_priv(dev);
1625 void __iomem *ioaddr = hmp->base;
1626
1627 if (intr_status & (LinkChange|NegotiationChange)) {
1628 if (hamachi_debug > 1)
1629 printk(KERN_INFO "%s: Link changed: AutoNegotiation Ctrl"
1630 " %4.4x, Status %4.4x %4.4x Intr status %4.4x.\n",
1631 dev->name, readw(ioaddr + 0x0E0), readw(ioaddr + 0x0E2),
1632 readw(ioaddr + ANLinkPartnerAbility),
1633 readl(ioaddr + IntrStatus));
1634 if (readw(ioaddr + ANStatus) & 0x20)
1635 writeb(0x01, ioaddr + LEDCtrl);
1636 else
1637 writeb(0x03, ioaddr + LEDCtrl);
1638 }
1639 if (intr_status & StatsMax) {
1640 hamachi_get_stats(dev);
1641
1642 readl(ioaddr + 0x370);
1643 readl(ioaddr + 0x3F0);
1644 }
1645 if ((intr_status & ~(LinkChange|StatsMax|NegotiationChange|IntrRxDone|IntrTxDone)) &&
1646 hamachi_debug)
1647 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1648 dev->name, intr_status);
1649
1650 if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))
1651 dev->stats.tx_fifo_errors++;
1652 if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))
1653 dev->stats.rx_fifo_errors++;
1654}
1655
1656static int hamachi_close(struct net_device *dev)
1657{
1658 struct hamachi_private *hmp = netdev_priv(dev);
1659 void __iomem *ioaddr = hmp->base;
1660 struct sk_buff *skb;
1661 int i;
1662
1663 netif_stop_queue(dev);
1664
1665 if (hamachi_debug > 1) {
1666 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %4.4x Rx %4.4x Int %2.2x.\n",
1667 dev->name, readw(ioaddr + TxStatus),
1668 readw(ioaddr + RxStatus), readl(ioaddr + IntrStatus));
1669 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
1670 dev->name, hmp->cur_tx, hmp->dirty_tx, hmp->cur_rx, hmp->dirty_rx);
1671 }
1672
1673
1674 writel(0x0000, ioaddr + InterruptEnable);
1675
1676
1677 writel(2, ioaddr + RxCmd);
1678 writew(2, ioaddr + TxCmd);
1679
1680#ifdef __i386__
1681 if (hamachi_debug > 2) {
1682 printk(KERN_DEBUG " Tx ring at %8.8x:\n",
1683 (int)hmp->tx_ring_dma);
1684 for (i = 0; i < TX_RING_SIZE; i++)
1685 printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x.\n",
1686 readl(ioaddr + TxCurPtr) == (long)&hmp->tx_ring[i] ? '>' : ' ',
1687 i, hmp->tx_ring[i].status_n_length, hmp->tx_ring[i].addr);
1688 printk(KERN_DEBUG " Rx ring %8.8x:\n",
1689 (int)hmp->rx_ring_dma);
1690 for (i = 0; i < RX_RING_SIZE; i++) {
1691 printk(KERN_DEBUG " %c #%d desc. %4.4x %8.8x\n",
1692 readl(ioaddr + RxCurPtr) == (long)&hmp->rx_ring[i] ? '>' : ' ',
1693 i, hmp->rx_ring[i].status_n_length, hmp->rx_ring[i].addr);
1694 if (hamachi_debug > 6) {
1695 if (*(u8*)hmp->rx_skbuff[i]->data != 0x69) {
1696 u16 *addr = (u16 *)
1697 hmp->rx_skbuff[i]->data;
1698 int j;
1699 printk(KERN_DEBUG "Addr: ");
1700 for (j = 0; j < 0x50; j++)
1701 printk(" %4.4x", addr[j]);
1702 printk("\n");
1703 }
1704 }
1705 }
1706 }
1707#endif
1708
1709 free_irq(hmp->pci_dev->irq, dev);
1710
1711 del_timer_sync(&hmp->timer);
1712
1713
1714 for (i = 0; i < RX_RING_SIZE; i++) {
1715 skb = hmp->rx_skbuff[i];
1716 hmp->rx_ring[i].status_n_length = 0;
1717 if (skb) {
1718 dma_unmap_single(&hmp->pci_dev->dev,
1719 leXX_to_cpu(hmp->rx_ring[i].addr),
1720 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1721 dev_kfree_skb(skb);
1722 hmp->rx_skbuff[i] = NULL;
1723 }
1724 hmp->rx_ring[i].addr = cpu_to_leXX(0xBADF00D0);
1725 }
1726 for (i = 0; i < TX_RING_SIZE; i++) {
1727 skb = hmp->tx_skbuff[i];
1728 if (skb) {
1729 dma_unmap_single(&hmp->pci_dev->dev,
1730 leXX_to_cpu(hmp->tx_ring[i].addr),
1731 skb->len, DMA_TO_DEVICE);
1732 dev_kfree_skb(skb);
1733 hmp->tx_skbuff[i] = NULL;
1734 }
1735 }
1736
1737 writeb(0x00, ioaddr + LEDCtrl);
1738
1739 return 0;
1740}
1741
1742static struct net_device_stats *hamachi_get_stats(struct net_device *dev)
1743{
1744 struct hamachi_private *hmp = netdev_priv(dev);
1745 void __iomem *ioaddr = hmp->base;
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758 dev->stats.rx_bytes = readl(ioaddr + 0x330);
1759
1760 dev->stats.tx_bytes = readl(ioaddr + 0x3B0);
1761
1762 dev->stats.multicast = readl(ioaddr + 0x320);
1763
1764
1765 dev->stats.rx_length_errors = readl(ioaddr + 0x368);
1766
1767 dev->stats.rx_over_errors = readl(ioaddr + 0x35C);
1768
1769 dev->stats.rx_crc_errors = readl(ioaddr + 0x360);
1770
1771 dev->stats.rx_frame_errors = readl(ioaddr + 0x364);
1772
1773 dev->stats.rx_missed_errors = readl(ioaddr + 0x36C);
1774
1775 return &dev->stats;
1776}
1777
1778static void set_rx_mode(struct net_device *dev)
1779{
1780 struct hamachi_private *hmp = netdev_priv(dev);
1781 void __iomem *ioaddr = hmp->base;
1782
1783 if (dev->flags & IFF_PROMISC) {
1784 writew(0x000F, ioaddr + AddrMode);
1785 } else if ((netdev_mc_count(dev) > 63) || (dev->flags & IFF_ALLMULTI)) {
1786
1787 writew(0x000B, ioaddr + AddrMode);
1788 } else if (!netdev_mc_empty(dev)) {
1789 struct netdev_hw_addr *ha;
1790 int i = 0;
1791
1792 netdev_for_each_mc_addr(ha, dev) {
1793 writel(*(u32 *)(ha->addr), ioaddr + 0x100 + i*8);
1794 writel(0x20000 | (*(u16 *)&ha->addr[4]),
1795 ioaddr + 0x104 + i*8);
1796 i++;
1797 }
1798
1799 for (; i < 64; i++)
1800 writel(0, ioaddr + 0x104 + i*8);
1801 writew(0x0003, ioaddr + AddrMode);
1802 } else {
1803 writew(0x0001, ioaddr + AddrMode);
1804 }
1805}
1806
1807static int check_if_running(struct net_device *dev)
1808{
1809 if (!netif_running(dev))
1810 return -EINVAL;
1811 return 0;
1812}
1813
1814static void hamachi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1815{
1816 struct hamachi_private *np = netdev_priv(dev);
1817
1818 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1819 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1820 strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1821}
1822
1823static int hamachi_get_link_ksettings(struct net_device *dev,
1824 struct ethtool_link_ksettings *cmd)
1825{
1826 struct hamachi_private *np = netdev_priv(dev);
1827 spin_lock_irq(&np->lock);
1828 mii_ethtool_get_link_ksettings(&np->mii_if, cmd);
1829 spin_unlock_irq(&np->lock);
1830 return 0;
1831}
1832
1833static int hamachi_set_link_ksettings(struct net_device *dev,
1834 const struct ethtool_link_ksettings *cmd)
1835{
1836 struct hamachi_private *np = netdev_priv(dev);
1837 int res;
1838 spin_lock_irq(&np->lock);
1839 res = mii_ethtool_set_link_ksettings(&np->mii_if, cmd);
1840 spin_unlock_irq(&np->lock);
1841 return res;
1842}
1843
1844static int hamachi_nway_reset(struct net_device *dev)
1845{
1846 struct hamachi_private *np = netdev_priv(dev);
1847 return mii_nway_restart(&np->mii_if);
1848}
1849
1850static u32 hamachi_get_link(struct net_device *dev)
1851{
1852 struct hamachi_private *np = netdev_priv(dev);
1853 return mii_link_ok(&np->mii_if);
1854}
1855
1856static const struct ethtool_ops ethtool_ops = {
1857 .begin = check_if_running,
1858 .get_drvinfo = hamachi_get_drvinfo,
1859 .nway_reset = hamachi_nway_reset,
1860 .get_link = hamachi_get_link,
1861 .get_link_ksettings = hamachi_get_link_ksettings,
1862 .set_link_ksettings = hamachi_set_link_ksettings,
1863};
1864
1865static const struct ethtool_ops ethtool_ops_no_mii = {
1866 .begin = check_if_running,
1867 .get_drvinfo = hamachi_get_drvinfo,
1868};
1869
1870static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1871{
1872 struct hamachi_private *np = netdev_priv(dev);
1873 struct mii_ioctl_data *data = if_mii(rq);
1874 int rc;
1875
1876 if (!netif_running(dev))
1877 return -EINVAL;
1878
1879 if (cmd == (SIOCDEVPRIVATE+3)) {
1880 u32 *d = (u32 *)&rq->ifr_ifru;
1881
1882
1883
1884
1885
1886 if (!capable(CAP_NET_ADMIN))
1887 return -EPERM;
1888 writel(d[0], np->base + TxIntrCtrl);
1889 writel(d[1], np->base + RxIntrCtrl);
1890 printk(KERN_NOTICE "%s: tx %08x, rx %08x intr\n", dev->name,
1891 (u32) readl(np->base + TxIntrCtrl),
1892 (u32) readl(np->base + RxIntrCtrl));
1893 rc = 0;
1894 }
1895
1896 else {
1897 spin_lock_irq(&np->lock);
1898 rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
1899 spin_unlock_irq(&np->lock);
1900 }
1901
1902 return rc;
1903}
1904
1905
1906static void hamachi_remove_one(struct pci_dev *pdev)
1907{
1908 struct net_device *dev = pci_get_drvdata(pdev);
1909
1910 if (dev) {
1911 struct hamachi_private *hmp = netdev_priv(dev);
1912
1913 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
1914 hmp->rx_ring_dma);
1915 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
1916 hmp->tx_ring_dma);
1917 unregister_netdev(dev);
1918 iounmap(hmp->base);
1919 free_netdev(dev);
1920 pci_release_regions(pdev);
1921 }
1922}
1923
1924static const struct pci_device_id hamachi_pci_tbl[] = {
1925 { 0x1318, 0x0911, PCI_ANY_ID, PCI_ANY_ID, },
1926 { 0, }
1927};
1928MODULE_DEVICE_TABLE(pci, hamachi_pci_tbl);
1929
1930static struct pci_driver hamachi_driver = {
1931 .name = DRV_NAME,
1932 .id_table = hamachi_pci_tbl,
1933 .probe = hamachi_init_one,
1934 .remove = hamachi_remove_one,
1935};
1936
1937static int __init hamachi_init (void)
1938{
1939
1940#ifdef MODULE
1941 printk(version);
1942#endif
1943 return pci_register_driver(&hamachi_driver);
1944}
1945
1946static void __exit hamachi_exit (void)
1947{
1948 pci_unregister_driver(&hamachi_driver);
1949}
1950
1951
1952module_init(hamachi_init);
1953module_exit(hamachi_exit);
1954