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 hamachi_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
550static int hamachi_siocdevprivate(struct net_device *dev, struct ifreq *rq,
551 void __user *data, int cmd);
552static void hamachi_timer(struct timer_list *t);
553static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue);
554static void hamachi_init_ring(struct net_device *dev);
555static netdev_tx_t hamachi_start_xmit(struct sk_buff *skb,
556 struct net_device *dev);
557static irqreturn_t hamachi_interrupt(int irq, void *dev_instance);
558static int hamachi_rx(struct net_device *dev);
559static inline int hamachi_tx(struct net_device *dev);
560static void hamachi_error(struct net_device *dev, int intr_status);
561static int hamachi_close(struct net_device *dev);
562static struct net_device_stats *hamachi_get_stats(struct net_device *dev);
563static void set_rx_mode(struct net_device *dev);
564static const struct ethtool_ops ethtool_ops;
565static const struct ethtool_ops ethtool_ops_no_mii;
566
567static const struct net_device_ops hamachi_netdev_ops = {
568 .ndo_open = hamachi_open,
569 .ndo_stop = hamachi_close,
570 .ndo_start_xmit = hamachi_start_xmit,
571 .ndo_get_stats = hamachi_get_stats,
572 .ndo_set_rx_mode = set_rx_mode,
573 .ndo_validate_addr = eth_validate_addr,
574 .ndo_set_mac_address = eth_mac_addr,
575 .ndo_tx_timeout = hamachi_tx_timeout,
576 .ndo_eth_ioctl = hamachi_ioctl,
577 .ndo_siocdevprivate = hamachi_siocdevprivate,
578};
579
580
581static int hamachi_init_one(struct pci_dev *pdev,
582 const struct pci_device_id *ent)
583{
584 struct hamachi_private *hmp;
585 int option, i, rx_int_var, tx_int_var, boguscnt;
586 int chip_id = ent->driver_data;
587 int irq;
588 void __iomem *ioaddr;
589 unsigned long base;
590 static int card_idx;
591 struct net_device *dev;
592 void *ring_space;
593 dma_addr_t ring_dma;
594 int ret = -ENOMEM;
595
596
597#ifndef MODULE
598 static int printed_version;
599 if (!printed_version++)
600 printk(version);
601#endif
602
603 if (pci_enable_device(pdev)) {
604 ret = -EIO;
605 goto err_out;
606 }
607
608 base = pci_resource_start(pdev, 0);
609#ifdef __alpha__
610 base |= (pci_resource_start(pdev, 1) << 32);
611#endif
612
613 pci_set_master(pdev);
614
615 i = pci_request_regions(pdev, DRV_NAME);
616 if (i)
617 return i;
618
619 irq = pdev->irq;
620 ioaddr = ioremap(base, 0x400);
621 if (!ioaddr)
622 goto err_out_release;
623
624 dev = alloc_etherdev(sizeof(struct hamachi_private));
625 if (!dev)
626 goto err_out_iounmap;
627
628 SET_NETDEV_DEV(dev, &pdev->dev);
629
630 for (i = 0; i < 6; i++)
631 dev->dev_addr[i] = 1 ? read_eeprom(ioaddr, 4 + i)
632 : readb(ioaddr + StationAddr + i);
633
634#if ! defined(final_version)
635 if (hamachi_debug > 4)
636 for (i = 0; i < 0x10; i++)
637 printk("%2.2x%s",
638 read_eeprom(ioaddr, i), i % 16 != 15 ? " " : "\n");
639#endif
640
641 hmp = netdev_priv(dev);
642 spin_lock_init(&hmp->lock);
643
644 hmp->mii_if.dev = dev;
645 hmp->mii_if.mdio_read = mdio_read;
646 hmp->mii_if.mdio_write = mdio_write;
647 hmp->mii_if.phy_id_mask = 0x1f;
648 hmp->mii_if.reg_num_mask = 0x1f;
649
650 ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE, &ring_dma,
651 GFP_KERNEL);
652 if (!ring_space)
653 goto err_out_cleardev;
654 hmp->tx_ring = ring_space;
655 hmp->tx_ring_dma = ring_dma;
656
657 ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE, &ring_dma,
658 GFP_KERNEL);
659 if (!ring_space)
660 goto err_out_unmap_tx;
661 hmp->rx_ring = ring_space;
662 hmp->rx_ring_dma = ring_dma;
663
664
665 option = card_idx < MAX_UNITS ? options[card_idx] : 0;
666 if (dev->mem_start)
667 option = dev->mem_start;
668
669
670 force32 = force32 ? force32 :
671 ((option >= 0) ? ((option & 0x00000070) >> 4) : 0 );
672 if (force32)
673 writeb(force32, ioaddr + VirtualJumpers);
674
675
676 writeb(0x01, ioaddr + ChipReset);
677
678
679
680
681
682 udelay(10);
683 i = readb(ioaddr + PCIClkMeas);
684 for (boguscnt = 0; (!(i & 0x080)) && boguscnt < 1000; boguscnt++){
685 udelay(10);
686 i = readb(ioaddr + PCIClkMeas);
687 }
688
689 hmp->base = ioaddr;
690 pci_set_drvdata(pdev, dev);
691
692 hmp->chip_id = chip_id;
693 hmp->pci_dev = pdev;
694
695
696 if (option > 0) {
697 hmp->option = option;
698 if (option & 0x200)
699 hmp->mii_if.full_duplex = 1;
700 else if (option & 0x080)
701 hmp->mii_if.full_duplex = 0;
702 hmp->default_port = option & 15;
703 if (hmp->default_port)
704 hmp->mii_if.force_media = 1;
705 }
706 if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
707 hmp->mii_if.full_duplex = 1;
708
709
710 if (hmp->mii_if.full_duplex || (option & 0x080))
711 hmp->duplex_lock = 1;
712
713
714 max_rx_latency = max_rx_latency & 0x00ff;
715 max_rx_gap = max_rx_gap & 0x00ff;
716 min_rx_pkt = min_rx_pkt & 0x00ff;
717 max_tx_latency = max_tx_latency & 0x00ff;
718 max_tx_gap = max_tx_gap & 0x00ff;
719 min_tx_pkt = min_tx_pkt & 0x00ff;
720
721 rx_int_var = card_idx < MAX_UNITS ? rx_params[card_idx] : -1;
722 tx_int_var = card_idx < MAX_UNITS ? tx_params[card_idx] : -1;
723 hmp->rx_int_var = rx_int_var >= 0 ? rx_int_var :
724 (min_rx_pkt << 16 | max_rx_gap << 8 | max_rx_latency);
725 hmp->tx_int_var = tx_int_var >= 0 ? tx_int_var :
726 (min_tx_pkt << 16 | max_tx_gap << 8 | max_tx_latency);
727
728
729
730 dev->netdev_ops = &hamachi_netdev_ops;
731 dev->ethtool_ops = (chip_tbl[hmp->chip_id].flags & CanHaveMII) ?
732 ðtool_ops : ðtool_ops_no_mii;
733 dev->watchdog_timeo = TX_TIMEOUT;
734 if (mtu)
735 dev->mtu = mtu;
736
737 i = register_netdev(dev);
738 if (i) {
739 ret = i;
740 goto err_out_unmap_rx;
741 }
742
743 printk(KERN_INFO "%s: %s type %x at %p, %pM, IRQ %d.\n",
744 dev->name, chip_tbl[chip_id].name, readl(ioaddr + ChipRev),
745 ioaddr, dev->dev_addr, irq);
746 i = readb(ioaddr + PCIClkMeas);
747 printk(KERN_INFO "%s: %d-bit %d Mhz PCI bus (%d), Virtual Jumpers "
748 "%2.2x, LPA %4.4x.\n",
749 dev->name, readw(ioaddr + MiscStatus) & 1 ? 64 : 32,
750 i ? 2000/(i&0x7f) : 0, i&0x7f, (int)readb(ioaddr + VirtualJumpers),
751 readw(ioaddr + ANLinkPartnerAbility));
752
753 if (chip_tbl[hmp->chip_id].flags & CanHaveMII) {
754 int phy, phy_idx = 0;
755 for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {
756 int mii_status = mdio_read(dev, phy, MII_BMSR);
757 if (mii_status != 0xffff &&
758 mii_status != 0x0000) {
759 hmp->phys[phy_idx++] = phy;
760 hmp->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
761 printk(KERN_INFO "%s: MII PHY found at address %d, status "
762 "0x%4.4x advertising %4.4x.\n",
763 dev->name, phy, mii_status, hmp->mii_if.advertising);
764 }
765 }
766 hmp->mii_cnt = phy_idx;
767 if (hmp->mii_cnt > 0)
768 hmp->mii_if.phy_id = hmp->phys[0];
769 else
770 memset(&hmp->mii_if, 0, sizeof(hmp->mii_if));
771 }
772
773 writew(0x0400, ioaddr + ANXchngCtrl);
774 writew(0x08e0, ioaddr + ANAdvertise);
775 writew(0x1000, ioaddr + ANCtrl);
776
777 card_idx++;
778 return 0;
779
780err_out_unmap_rx:
781 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
782 hmp->rx_ring_dma);
783err_out_unmap_tx:
784 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
785 hmp->tx_ring_dma);
786err_out_cleardev:
787 free_netdev (dev);
788err_out_iounmap:
789 iounmap(ioaddr);
790err_out_release:
791 pci_release_regions(pdev);
792err_out:
793 return ret;
794}
795
796static int read_eeprom(void __iomem *ioaddr, int location)
797{
798 int bogus_cnt = 1000;
799
800
801 while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);
802 writew(location, ioaddr + EEAddr);
803 writeb(0x02, ioaddr + EECmdStatus);
804 bogus_cnt = 1000;
805 while ((readb(ioaddr + EECmdStatus) & 0x40) && --bogus_cnt > 0);
806 if (hamachi_debug > 5)
807 printk(" EEPROM status is %2.2x after %d ticks.\n",
808 (int)readb(ioaddr + EECmdStatus), 1000- bogus_cnt);
809 return readb(ioaddr + EEData);
810}
811
812
813
814
815
816static int mdio_read(struct net_device *dev, int phy_id, int location)
817{
818 struct hamachi_private *hmp = netdev_priv(dev);
819 void __iomem *ioaddr = hmp->base;
820 int i;
821
822
823 for (i = 10000; i >= 0; i--)
824 if ((readw(ioaddr + MII_Status) & 1) == 0)
825 break;
826 writew((phy_id<<8) + location, ioaddr + MII_Addr);
827 writew(0x0001, ioaddr + MII_Cmd);
828 for (i = 10000; i >= 0; i--)
829 if ((readw(ioaddr + MII_Status) & 1) == 0)
830 break;
831 return readw(ioaddr + MII_Rd_Data);
832}
833
834static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
835{
836 struct hamachi_private *hmp = netdev_priv(dev);
837 void __iomem *ioaddr = hmp->base;
838 int i;
839
840
841 for (i = 10000; i >= 0; i--)
842 if ((readw(ioaddr + MII_Status) & 1) == 0)
843 break;
844 writew((phy_id<<8) + location, ioaddr + MII_Addr);
845 writew(value, ioaddr + MII_Wr_Data);
846
847
848 for (i = 10000; i >= 0; i--)
849 if ((readw(ioaddr + MII_Status) & 1) == 0)
850 break;
851}
852
853
854static int hamachi_open(struct net_device *dev)
855{
856 struct hamachi_private *hmp = netdev_priv(dev);
857 void __iomem *ioaddr = hmp->base;
858 int i;
859 u32 rx_int_var, tx_int_var;
860 u16 fifo_info;
861
862 i = request_irq(hmp->pci_dev->irq, hamachi_interrupt, IRQF_SHARED,
863 dev->name, dev);
864 if (i)
865 return i;
866
867 hamachi_init_ring(dev);
868
869#if ADDRLEN == 64
870
871 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
872 writel(hmp->rx_ring_dma >> 32, ioaddr + RxPtr + 4);
873 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
874 writel(hmp->tx_ring_dma >> 32, ioaddr + TxPtr + 4);
875#else
876 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
877 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
878#endif
879
880
881
882
883 for (i = 0; i < 6; i++)
884 writeb(dev->dev_addr[i], ioaddr + StationAddr + i);
885
886
887
888
889
890 fifo_info = (readw(ioaddr + GPIO) & 0x00C0) >> 6;
891 switch (fifo_info){
892 case 0 :
893
894 writew(0x0000, ioaddr + FIFOcfg);
895 break;
896 case 1 :
897
898 writew(0x0028, ioaddr + FIFOcfg);
899 break;
900 case 2 :
901
902 writew(0x004C, ioaddr + FIFOcfg);
903 break;
904 case 3 :
905
906 writew(0x006C, ioaddr + FIFOcfg);
907 break;
908 default :
909 printk(KERN_WARNING "%s: Unsupported external memory config!\n",
910 dev->name);
911
912 writew(0x0000, ioaddr + FIFOcfg);
913 break;
914 }
915
916 if (dev->if_port == 0)
917 dev->if_port = hmp->default_port;
918
919
920
921
922 if (hmp->duplex_lock != 1)
923 hmp->mii_if.full_duplex = 1;
924
925
926 writew(0x0001, ioaddr + RxChecksum);
927 writew(0x0000, ioaddr + TxChecksum);
928 writew(0x8000, ioaddr + MACCnfg);
929 writew(0x215F, ioaddr + MACCnfg);
930 writew(0x000C, ioaddr + FrameGap0);
931
932 writew(0x1018, ioaddr + FrameGap1);
933
934 writew(0x0780, ioaddr + MACCnfg2);
935
936 writel(0x0030FFFF, ioaddr + FlowCtrl);
937 writew(MAX_FRAME_SIZE, ioaddr + MaxFrameSize);
938
939
940 writew(0x0400, ioaddr + ANXchngCtrl);
941
942 writeb(0x03, ioaddr + LEDCtrl);
943
944
945
946
947 rx_int_var = hmp->rx_int_var;
948 tx_int_var = hmp->tx_int_var;
949
950 if (hamachi_debug > 1) {
951 printk("max_tx_latency: %d, max_tx_gap: %d, min_tx_pkt: %d\n",
952 tx_int_var & 0x00ff, (tx_int_var & 0x00ff00) >> 8,
953 (tx_int_var & 0x00ff0000) >> 16);
954 printk("max_rx_latency: %d, max_rx_gap: %d, min_rx_pkt: %d\n",
955 rx_int_var & 0x00ff, (rx_int_var & 0x00ff00) >> 8,
956 (rx_int_var & 0x00ff0000) >> 16);
957 printk("rx_int_var: %x, tx_int_var: %x\n", rx_int_var, tx_int_var);
958 }
959
960 writel(tx_int_var, ioaddr + TxIntrCtrl);
961 writel(rx_int_var, ioaddr + RxIntrCtrl);
962
963 set_rx_mode(dev);
964
965 netif_start_queue(dev);
966
967
968 writel(0x80878787, ioaddr + InterruptEnable);
969 writew(0x0000, ioaddr + EventStatus);
970
971
972
973#if ADDRLEN == 64
974 writew(0x005D, ioaddr + RxDMACtrl);
975 writew(0x005D, ioaddr + TxDMACtrl);
976#else
977 writew(0x001D, ioaddr + RxDMACtrl);
978 writew(0x001D, ioaddr + TxDMACtrl);
979#endif
980 writew(0x0001, ioaddr + RxCmd);
981
982 if (hamachi_debug > 2) {
983 printk(KERN_DEBUG "%s: Done hamachi_open(), status: Rx %x Tx %x.\n",
984 dev->name, readw(ioaddr + RxStatus), readw(ioaddr + TxStatus));
985 }
986
987 timer_setup(&hmp->timer, hamachi_timer, 0);
988 hmp->timer.expires = RUN_AT((24*HZ)/10);
989 add_timer(&hmp->timer);
990
991 return 0;
992}
993
994static inline int hamachi_tx(struct net_device *dev)
995{
996 struct hamachi_private *hmp = netdev_priv(dev);
997
998
999
1000 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++) {
1001 int entry = hmp->dirty_tx % TX_RING_SIZE;
1002 struct sk_buff *skb;
1003
1004 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1005 break;
1006
1007 skb = hmp->tx_skbuff[entry];
1008 if (skb) {
1009 dma_unmap_single(&hmp->pci_dev->dev,
1010 leXX_to_cpu(hmp->tx_ring[entry].addr),
1011 skb->len, DMA_TO_DEVICE);
1012 dev_kfree_skb(skb);
1013 hmp->tx_skbuff[entry] = NULL;
1014 }
1015 hmp->tx_ring[entry].status_n_length = 0;
1016 if (entry >= TX_RING_SIZE-1)
1017 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1018 cpu_to_le32(DescEndRing);
1019 dev->stats.tx_packets++;
1020 }
1021
1022 return 0;
1023}
1024
1025static void hamachi_timer(struct timer_list *t)
1026{
1027 struct hamachi_private *hmp = from_timer(hmp, t, timer);
1028 struct net_device *dev = hmp->mii_if.dev;
1029 void __iomem *ioaddr = hmp->base;
1030 int next_tick = 10*HZ;
1031
1032 if (hamachi_debug > 2) {
1033 printk(KERN_INFO "%s: Hamachi Autonegotiation status %4.4x, LPA "
1034 "%4.4x.\n", dev->name, readw(ioaddr + ANStatus),
1035 readw(ioaddr + ANLinkPartnerAbility));
1036 printk(KERN_INFO "%s: Autonegotiation regs %4.4x %4.4x %4.4x "
1037 "%4.4x %4.4x %4.4x.\n", dev->name,
1038 readw(ioaddr + 0x0e0),
1039 readw(ioaddr + 0x0e2),
1040 readw(ioaddr + 0x0e4),
1041 readw(ioaddr + 0x0e6),
1042 readw(ioaddr + 0x0e8),
1043 readw(ioaddr + 0x0eA));
1044 }
1045
1046 hmp->timer.expires = RUN_AT(next_tick);
1047 add_timer(&hmp->timer);
1048}
1049
1050static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue)
1051{
1052 int i;
1053 struct hamachi_private *hmp = netdev_priv(dev);
1054 void __iomem *ioaddr = hmp->base;
1055
1056 printk(KERN_WARNING "%s: Hamachi transmit timed out, status %8.8x,"
1057 " resetting...\n", dev->name, (int)readw(ioaddr + TxStatus));
1058
1059 {
1060 printk(KERN_DEBUG " Rx ring %p: ", hmp->rx_ring);
1061 for (i = 0; i < RX_RING_SIZE; i++)
1062 printk(KERN_CONT " %8.8x",
1063 le32_to_cpu(hmp->rx_ring[i].status_n_length));
1064 printk(KERN_CONT "\n");
1065 printk(KERN_DEBUG" Tx ring %p: ", hmp->tx_ring);
1066 for (i = 0; i < TX_RING_SIZE; i++)
1067 printk(KERN_CONT " %4.4x",
1068 le32_to_cpu(hmp->tx_ring[i].status_n_length));
1069 printk(KERN_CONT "\n");
1070 }
1071
1072
1073
1074
1075 dev->if_port = 0;
1076
1077
1078
1079
1080
1081
1082
1083 for (i = 0; i < RX_RING_SIZE; i++)
1084 hmp->rx_ring[i].status_n_length &= cpu_to_le32(~DescOwn);
1085
1086
1087
1088
1089 for (i = 0; i < TX_RING_SIZE; i++){
1090 struct sk_buff *skb;
1091
1092 if (i >= TX_RING_SIZE - 1)
1093 hmp->tx_ring[i].status_n_length =
1094 cpu_to_le32(DescEndRing) |
1095 (hmp->tx_ring[i].status_n_length &
1096 cpu_to_le32(0x0000ffff));
1097 else
1098 hmp->tx_ring[i].status_n_length &= cpu_to_le32(0x0000ffff);
1099 skb = hmp->tx_skbuff[i];
1100 if (skb){
1101 dma_unmap_single(&hmp->pci_dev->dev,
1102 leXX_to_cpu(hmp->tx_ring[i].addr),
1103 skb->len, DMA_TO_DEVICE);
1104 dev_kfree_skb(skb);
1105 hmp->tx_skbuff[i] = NULL;
1106 }
1107 }
1108
1109 udelay(60);
1110 writew(0x0002, ioaddr + RxCmd);
1111
1112 writeb(0x01, ioaddr + ChipReset);
1113
1114 hmp->tx_full = 0;
1115 hmp->cur_rx = hmp->cur_tx = 0;
1116 hmp->dirty_rx = hmp->dirty_tx = 0;
1117
1118
1119
1120 for (i = 0; i < RX_RING_SIZE; i++){
1121 struct sk_buff *skb = hmp->rx_skbuff[i];
1122
1123 if (skb){
1124 dma_unmap_single(&hmp->pci_dev->dev,
1125 leXX_to_cpu(hmp->rx_ring[i].addr),
1126 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1127 dev_kfree_skb(skb);
1128 hmp->rx_skbuff[i] = NULL;
1129 }
1130 }
1131
1132 for (i = 0; i < RX_RING_SIZE; i++) {
1133 struct sk_buff *skb;
1134
1135 skb = netdev_alloc_skb_ip_align(dev, hmp->rx_buf_sz);
1136 hmp->rx_skbuff[i] = skb;
1137 if (skb == NULL)
1138 break;
1139
1140 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1141 skb->data,
1142 hmp->rx_buf_sz,
1143 DMA_FROM_DEVICE));
1144 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1145 DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));
1146 }
1147 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1148
1149 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1150
1151
1152 netif_trans_update(dev);
1153 dev->stats.tx_errors++;
1154
1155
1156 writew(0x0002, ioaddr + TxCmd);
1157 writew(0x0001, ioaddr + TxCmd);
1158 writew(0x0001, ioaddr + RxCmd);
1159
1160 netif_wake_queue(dev);
1161}
1162
1163
1164
1165static void hamachi_init_ring(struct net_device *dev)
1166{
1167 struct hamachi_private *hmp = netdev_priv(dev);
1168 int i;
1169
1170 hmp->tx_full = 0;
1171 hmp->cur_rx = hmp->cur_tx = 0;
1172 hmp->dirty_rx = hmp->dirty_tx = 0;
1173
1174
1175
1176
1177
1178
1179 hmp->rx_buf_sz = (dev->mtu <= 1492 ? PKT_BUF_SZ :
1180 (((dev->mtu+26+7) & ~7) + 16));
1181
1182
1183 for (i = 0; i < RX_RING_SIZE; i++) {
1184 hmp->rx_ring[i].status_n_length = 0;
1185 hmp->rx_skbuff[i] = NULL;
1186 }
1187
1188 for (i = 0; i < RX_RING_SIZE; i++) {
1189 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1190 hmp->rx_skbuff[i] = skb;
1191 if (skb == NULL)
1192 break;
1193 skb_reserve(skb, 2);
1194 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1195 skb->data,
1196 hmp->rx_buf_sz,
1197 DMA_FROM_DEVICE));
1198
1199 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1200 DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));
1201 }
1202 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1203 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1204
1205 for (i = 0; i < TX_RING_SIZE; i++) {
1206 hmp->tx_skbuff[i] = NULL;
1207 hmp->tx_ring[i].status_n_length = 0;
1208 }
1209
1210 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1211}
1212
1213
1214static netdev_tx_t hamachi_start_xmit(struct sk_buff *skb,
1215 struct net_device *dev)
1216{
1217 struct hamachi_private *hmp = netdev_priv(dev);
1218 unsigned entry;
1219 u16 status;
1220
1221
1222
1223
1224
1225
1226 if (hmp->tx_full) {
1227
1228 printk(KERN_WARNING "%s: Hamachi transmit queue full at slot %d.\n",dev->name, hmp->cur_tx);
1229
1230
1231
1232 status=readw(hmp->base + TxStatus);
1233 if( !(status & 0x0001) || (status & 0x0002))
1234 writew(0x0001, hmp->base + TxCmd);
1235 return NETDEV_TX_BUSY;
1236 }
1237
1238
1239
1240
1241
1242 entry = hmp->cur_tx % TX_RING_SIZE;
1243
1244 hmp->tx_skbuff[entry] = skb;
1245
1246 hmp->tx_ring[entry].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1247 skb->data,
1248 skb->len,
1249 DMA_TO_DEVICE));
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260 if (entry >= TX_RING_SIZE-1)
1261 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1262 DescEndPacket | DescEndRing | DescIntr | skb->len);
1263 else
1264 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1265 DescEndPacket | DescIntr | skb->len);
1266 hmp->cur_tx++;
1267
1268
1269
1270
1271
1272 status=readw(hmp->base + TxStatus);
1273 if( !(status & 0x0001) || (status & 0x0002))
1274 writew(0x0001, hmp->base + TxCmd);
1275
1276
1277 hamachi_tx(dev);
1278
1279
1280
1281
1282
1283
1284
1285 if ((hmp->cur_tx - hmp->dirty_tx) < (TX_RING_SIZE - 4))
1286 netif_wake_queue(dev);
1287 else {
1288 hmp->tx_full = 1;
1289 netif_stop_queue(dev);
1290 }
1291
1292 if (hamachi_debug > 4) {
1293 printk(KERN_DEBUG "%s: Hamachi transmit frame #%d queued in slot %d.\n",
1294 dev->name, hmp->cur_tx, entry);
1295 }
1296 return NETDEV_TX_OK;
1297}
1298
1299
1300
1301static irqreturn_t hamachi_interrupt(int irq, void *dev_instance)
1302{
1303 struct net_device *dev = dev_instance;
1304 struct hamachi_private *hmp = netdev_priv(dev);
1305 void __iomem *ioaddr = hmp->base;
1306 long boguscnt = max_interrupt_work;
1307 int handled = 0;
1308
1309#ifndef final_version
1310 if (dev == NULL) {
1311 printk (KERN_ERR "hamachi_interrupt(): irq %d for unknown device.\n", irq);
1312 return IRQ_NONE;
1313 }
1314#endif
1315
1316 spin_lock(&hmp->lock);
1317
1318 do {
1319 u32 intr_status = readl(ioaddr + InterruptClear);
1320
1321 if (hamachi_debug > 4)
1322 printk(KERN_DEBUG "%s: Hamachi interrupt, status %4.4x.\n",
1323 dev->name, intr_status);
1324
1325 if (intr_status == 0)
1326 break;
1327
1328 handled = 1;
1329
1330 if (intr_status & IntrRxDone)
1331 hamachi_rx(dev);
1332
1333 if (intr_status & IntrTxDone){
1334
1335
1336
1337
1338 if (hmp->tx_full){
1339 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++){
1340 int entry = hmp->dirty_tx % TX_RING_SIZE;
1341 struct sk_buff *skb;
1342
1343 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1344 break;
1345 skb = hmp->tx_skbuff[entry];
1346
1347 if (skb){
1348 dma_unmap_single(&hmp->pci_dev->dev,
1349 leXX_to_cpu(hmp->tx_ring[entry].addr),
1350 skb->len,
1351 DMA_TO_DEVICE);
1352 dev_consume_skb_irq(skb);
1353 hmp->tx_skbuff[entry] = NULL;
1354 }
1355 hmp->tx_ring[entry].status_n_length = 0;
1356 if (entry >= TX_RING_SIZE-1)
1357 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1358 cpu_to_le32(DescEndRing);
1359 dev->stats.tx_packets++;
1360 }
1361 if (hmp->cur_tx - hmp->dirty_tx < TX_RING_SIZE - 4){
1362
1363 hmp->tx_full = 0;
1364 netif_wake_queue(dev);
1365 }
1366 } else {
1367 netif_wake_queue(dev);
1368 }
1369 }
1370
1371
1372
1373 if (intr_status &
1374 (IntrTxPCIFault | IntrTxPCIErr | IntrRxPCIFault | IntrRxPCIErr |
1375 LinkChange | NegotiationChange | StatsMax))
1376 hamachi_error(dev, intr_status);
1377
1378 if (--boguscnt < 0) {
1379 printk(KERN_WARNING "%s: Too much work at interrupt, status=0x%4.4x.\n",
1380 dev->name, intr_status);
1381 break;
1382 }
1383 } while (1);
1384
1385 if (hamachi_debug > 3)
1386 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1387 dev->name, readl(ioaddr + IntrStatus));
1388
1389#ifndef final_version
1390
1391 {
1392 static int stopit = 10;
1393 if (dev->start == 0 && --stopit < 0) {
1394 printk(KERN_ERR "%s: Emergency stop, looping startup interrupt.\n",
1395 dev->name);
1396 free_irq(irq, dev);
1397 }
1398 }
1399#endif
1400
1401 spin_unlock(&hmp->lock);
1402 return IRQ_RETVAL(handled);
1403}
1404
1405
1406
1407static int hamachi_rx(struct net_device *dev)
1408{
1409 struct hamachi_private *hmp = netdev_priv(dev);
1410 int entry = hmp->cur_rx % RX_RING_SIZE;
1411 int boguscnt = (hmp->dirty_rx + RX_RING_SIZE) - hmp->cur_rx;
1412
1413 if (hamachi_debug > 4) {
1414 printk(KERN_DEBUG " In hamachi_rx(), entry %d status %4.4x.\n",
1415 entry, hmp->rx_ring[entry].status_n_length);
1416 }
1417
1418
1419 while (1) {
1420 struct hamachi_desc *desc = &(hmp->rx_ring[entry]);
1421 u32 desc_status = le32_to_cpu(desc->status_n_length);
1422 u16 data_size = desc_status;
1423 u8 *buf_addr;
1424 s32 frame_status;
1425
1426 if (desc_status & DescOwn)
1427 break;
1428 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1429 leXX_to_cpu(desc->addr),
1430 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1431 buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
1432 frame_status = get_unaligned_le32(&(buf_addr[data_size - 12]));
1433 if (hamachi_debug > 4)
1434 printk(KERN_DEBUG " hamachi_rx() status was %8.8x.\n",
1435 frame_status);
1436 if (--boguscnt < 0)
1437 break;
1438 if ( ! (desc_status & DescEndPacket)) {
1439 printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "
1440 "multiple buffers, entry %#x length %d status %4.4x!\n",
1441 dev->name, hmp->cur_rx, data_size, desc_status);
1442 printk(KERN_WARNING "%s: Oversized Ethernet frame %p vs %p.\n",
1443 dev->name, desc, &hmp->rx_ring[hmp->cur_rx % RX_RING_SIZE]);
1444 printk(KERN_WARNING "%s: Oversized Ethernet frame -- next status %x/%x last status %x.\n",
1445 dev->name,
1446 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0xffff0000,
1447 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0x0000ffff,
1448 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length));
1449 dev->stats.rx_length_errors++;
1450 }
1451 if (frame_status & 0x00380000) {
1452
1453 if (hamachi_debug > 2)
1454 printk(KERN_DEBUG " hamachi_rx() Rx error was %8.8x.\n",
1455 frame_status);
1456 dev->stats.rx_errors++;
1457 if (frame_status & 0x00600000)
1458 dev->stats.rx_length_errors++;
1459 if (frame_status & 0x00080000)
1460 dev->stats.rx_frame_errors++;
1461 if (frame_status & 0x00100000)
1462 dev->stats.rx_crc_errors++;
1463 if (frame_status < 0)
1464 dev->stats.rx_dropped++;
1465 } else {
1466 struct sk_buff *skb;
1467
1468 u16 pkt_len = (frame_status & 0x07ff) - 4;
1469#ifdef RX_CHECKSUM
1470 u32 pfck = *(u32 *) &buf_addr[data_size - 8];
1471#endif
1472
1473
1474#ifndef final_version
1475 if (hamachi_debug > 4)
1476 printk(KERN_DEBUG " hamachi_rx() normal Rx pkt length %d"
1477 " of %d, bogus_cnt %d.\n",
1478 pkt_len, data_size, boguscnt);
1479 if (hamachi_debug > 5)
1480 printk(KERN_DEBUG"%s: rx status %8.8x %8.8x %8.8x %8.8x %8.8x.\n",
1481 dev->name,
1482 *(s32*)&(buf_addr[data_size - 20]),
1483 *(s32*)&(buf_addr[data_size - 16]),
1484 *(s32*)&(buf_addr[data_size - 12]),
1485 *(s32*)&(buf_addr[data_size - 8]),
1486 *(s32*)&(buf_addr[data_size - 4]));
1487#endif
1488
1489
1490 if (pkt_len < rx_copybreak &&
1491 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
1492#ifdef RX_CHECKSUM
1493 printk(KERN_ERR "%s: rx_copybreak non-zero "
1494 "not good with RX_CHECKSUM\n", dev->name);
1495#endif
1496 skb_reserve(skb, 2);
1497 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1498 leXX_to_cpu(hmp->rx_ring[entry].addr),
1499 hmp->rx_buf_sz,
1500 DMA_FROM_DEVICE);
1501
1502#if 1 || USE_IP_COPYSUM
1503 skb_copy_to_linear_data(skb,
1504 hmp->rx_skbuff[entry]->data, pkt_len);
1505 skb_put(skb, pkt_len);
1506#else
1507 skb_put_data(skb, hmp->rx_ring_dma
1508 + entry*sizeof(*desc), pkt_len);
1509#endif
1510 dma_sync_single_for_device(&hmp->pci_dev->dev,
1511 leXX_to_cpu(hmp->rx_ring[entry].addr),
1512 hmp->rx_buf_sz,
1513 DMA_FROM_DEVICE);
1514 } else {
1515 dma_unmap_single(&hmp->pci_dev->dev,
1516 leXX_to_cpu(hmp->rx_ring[entry].addr),
1517 hmp->rx_buf_sz,
1518 DMA_FROM_DEVICE);
1519 skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
1520 hmp->rx_skbuff[entry] = NULL;
1521 }
1522 skb->protocol = eth_type_trans(skb, dev);
1523
1524
1525#ifdef RX_CHECKSUM
1526
1527 if (pfck>>24 == 0x91 || pfck>>24 == 0x51) {
1528 struct iphdr *ih = (struct iphdr *) skb->data;
1529
1530
1531
1532
1533 if (ntohs(ih->tot_len) >= 46){
1534
1535 if (!(ih->frag_off & cpu_to_be16(IP_MF|IP_OFFSET))) {
1536 u32 inv = *(u32 *) &buf_addr[data_size - 16];
1537 u32 *p = (u32 *) &buf_addr[data_size - 20];
1538 register u32 crc, p_r, p_r1;
1539
1540 if (inv & 4) {
1541 inv &= ~4;
1542 --p;
1543 }
1544 p_r = *p;
1545 p_r1 = *(p-1);
1546 switch (inv) {
1547 case 0:
1548 crc = (p_r & 0xffff) + (p_r >> 16);
1549 break;
1550 case 1:
1551 crc = (p_r >> 16) + (p_r & 0xffff)
1552 + (p_r1 >> 16 & 0xff00);
1553 break;
1554 case 2:
1555 crc = p_r + (p_r1 >> 16);
1556 break;
1557 case 3:
1558 crc = p_r + (p_r1 & 0xff00) + (p_r1 >> 16);
1559 break;
1560 default: crc = 0;
1561 }
1562 if (crc & 0xffff0000) {
1563 crc &= 0xffff;
1564 ++crc;
1565 }
1566
1567 skb->csum = ntohs(pfck & 0xffff);
1568 if (skb->csum > crc)
1569 skb->csum -= crc;
1570 else
1571 skb->csum += (~crc & 0xffff);
1572
1573
1574
1575
1576 skb->ip_summed = CHECKSUM_COMPLETE;
1577 }
1578 }
1579 }
1580#endif
1581
1582 netif_rx(skb);
1583 dev->stats.rx_packets++;
1584 }
1585 entry = (++hmp->cur_rx) % RX_RING_SIZE;
1586 }
1587
1588
1589 for (; hmp->cur_rx - hmp->dirty_rx > 0; hmp->dirty_rx++) {
1590 struct hamachi_desc *desc;
1591
1592 entry = hmp->dirty_rx % RX_RING_SIZE;
1593 desc = &(hmp->rx_ring[entry]);
1594 if (hmp->rx_skbuff[entry] == NULL) {
1595 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1596
1597 hmp->rx_skbuff[entry] = skb;
1598 if (skb == NULL)
1599 break;
1600 skb_reserve(skb, 2);
1601 desc->addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1602 skb->data,
1603 hmp->rx_buf_sz,
1604 DMA_FROM_DEVICE));
1605 }
1606 desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);
1607 if (entry >= RX_RING_SIZE-1)
1608 desc->status_n_length |= cpu_to_le32(DescOwn |
1609 DescEndPacket | DescEndRing | DescIntr);
1610 else
1611 desc->status_n_length |= cpu_to_le32(DescOwn |
1612 DescEndPacket | DescIntr);
1613 }
1614
1615
1616
1617 if (readw(hmp->base + RxStatus) & 0x0002)
1618 writew(0x0001, hmp->base + RxCmd);
1619
1620 return 0;
1621}
1622
1623
1624
1625static void hamachi_error(struct net_device *dev, int intr_status)
1626{
1627 struct hamachi_private *hmp = netdev_priv(dev);
1628 void __iomem *ioaddr = hmp->base;
1629
1630 if (intr_status & (LinkChange|NegotiationChange)) {
1631 if (hamachi_debug > 1)
1632 printk(KERN_INFO "%s: Link changed: AutoNegotiation Ctrl"
1633 " %4.4x, Status %4.4x %4.4x Intr status %4.4x.\n",
1634 dev->name, readw(ioaddr + 0x0E0), readw(ioaddr + 0x0E2),
1635 readw(ioaddr + ANLinkPartnerAbility),
1636 readl(ioaddr + IntrStatus));
1637 if (readw(ioaddr + ANStatus) & 0x20)
1638 writeb(0x01, ioaddr + LEDCtrl);
1639 else
1640 writeb(0x03, ioaddr + LEDCtrl);
1641 }
1642 if (intr_status & StatsMax) {
1643 hamachi_get_stats(dev);
1644
1645 readl(ioaddr + 0x370);
1646 readl(ioaddr + 0x3F0);
1647 }
1648 if ((intr_status & ~(LinkChange|StatsMax|NegotiationChange|IntrRxDone|IntrTxDone)) &&
1649 hamachi_debug)
1650 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1651 dev->name, intr_status);
1652
1653 if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))
1654 dev->stats.tx_fifo_errors++;
1655 if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))
1656 dev->stats.rx_fifo_errors++;
1657}
1658
1659static int hamachi_close(struct net_device *dev)
1660{
1661 struct hamachi_private *hmp = netdev_priv(dev);
1662 void __iomem *ioaddr = hmp->base;
1663 struct sk_buff *skb;
1664 int i;
1665
1666 netif_stop_queue(dev);
1667
1668 if (hamachi_debug > 1) {
1669 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %4.4x Rx %4.4x Int %2.2x.\n",
1670 dev->name, readw(ioaddr + TxStatus),
1671 readw(ioaddr + RxStatus), readl(ioaddr + IntrStatus));
1672 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
1673 dev->name, hmp->cur_tx, hmp->dirty_tx, hmp->cur_rx, hmp->dirty_rx);
1674 }
1675
1676
1677 writel(0x0000, ioaddr + InterruptEnable);
1678
1679
1680 writel(2, ioaddr + RxCmd);
1681 writew(2, ioaddr + TxCmd);
1682
1683#ifdef __i386__
1684 if (hamachi_debug > 2) {
1685 printk(KERN_DEBUG " Tx ring at %8.8x:\n",
1686 (int)hmp->tx_ring_dma);
1687 for (i = 0; i < TX_RING_SIZE; i++)
1688 printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x.\n",
1689 readl(ioaddr + TxCurPtr) == (long)&hmp->tx_ring[i] ? '>' : ' ',
1690 i, hmp->tx_ring[i].status_n_length, hmp->tx_ring[i].addr);
1691 printk(KERN_DEBUG " Rx ring %8.8x:\n",
1692 (int)hmp->rx_ring_dma);
1693 for (i = 0; i < RX_RING_SIZE; i++) {
1694 printk(KERN_DEBUG " %c #%d desc. %4.4x %8.8x\n",
1695 readl(ioaddr + RxCurPtr) == (long)&hmp->rx_ring[i] ? '>' : ' ',
1696 i, hmp->rx_ring[i].status_n_length, hmp->rx_ring[i].addr);
1697 if (hamachi_debug > 6) {
1698 if (*(u8*)hmp->rx_skbuff[i]->data != 0x69) {
1699 u16 *addr = (u16 *)
1700 hmp->rx_skbuff[i]->data;
1701 int j;
1702 printk(KERN_DEBUG "Addr: ");
1703 for (j = 0; j < 0x50; j++)
1704 printk(" %4.4x", addr[j]);
1705 printk("\n");
1706 }
1707 }
1708 }
1709 }
1710#endif
1711
1712 free_irq(hmp->pci_dev->irq, dev);
1713
1714 del_timer_sync(&hmp->timer);
1715
1716
1717 for (i = 0; i < RX_RING_SIZE; i++) {
1718 skb = hmp->rx_skbuff[i];
1719 hmp->rx_ring[i].status_n_length = 0;
1720 if (skb) {
1721 dma_unmap_single(&hmp->pci_dev->dev,
1722 leXX_to_cpu(hmp->rx_ring[i].addr),
1723 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1724 dev_kfree_skb(skb);
1725 hmp->rx_skbuff[i] = NULL;
1726 }
1727 hmp->rx_ring[i].addr = cpu_to_leXX(0xBADF00D0);
1728 }
1729 for (i = 0; i < TX_RING_SIZE; i++) {
1730 skb = hmp->tx_skbuff[i];
1731 if (skb) {
1732 dma_unmap_single(&hmp->pci_dev->dev,
1733 leXX_to_cpu(hmp->tx_ring[i].addr),
1734 skb->len, DMA_TO_DEVICE);
1735 dev_kfree_skb(skb);
1736 hmp->tx_skbuff[i] = NULL;
1737 }
1738 }
1739
1740 writeb(0x00, ioaddr + LEDCtrl);
1741
1742 return 0;
1743}
1744
1745static struct net_device_stats *hamachi_get_stats(struct net_device *dev)
1746{
1747 struct hamachi_private *hmp = netdev_priv(dev);
1748 void __iomem *ioaddr = hmp->base;
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761 dev->stats.rx_bytes = readl(ioaddr + 0x330);
1762
1763 dev->stats.tx_bytes = readl(ioaddr + 0x3B0);
1764
1765 dev->stats.multicast = readl(ioaddr + 0x320);
1766
1767
1768 dev->stats.rx_length_errors = readl(ioaddr + 0x368);
1769
1770 dev->stats.rx_over_errors = readl(ioaddr + 0x35C);
1771
1772 dev->stats.rx_crc_errors = readl(ioaddr + 0x360);
1773
1774 dev->stats.rx_frame_errors = readl(ioaddr + 0x364);
1775
1776 dev->stats.rx_missed_errors = readl(ioaddr + 0x36C);
1777
1778 return &dev->stats;
1779}
1780
1781static void set_rx_mode(struct net_device *dev)
1782{
1783 struct hamachi_private *hmp = netdev_priv(dev);
1784 void __iomem *ioaddr = hmp->base;
1785
1786 if (dev->flags & IFF_PROMISC) {
1787 writew(0x000F, ioaddr + AddrMode);
1788 } else if ((netdev_mc_count(dev) > 63) || (dev->flags & IFF_ALLMULTI)) {
1789
1790 writew(0x000B, ioaddr + AddrMode);
1791 } else if (!netdev_mc_empty(dev)) {
1792 struct netdev_hw_addr *ha;
1793 int i = 0;
1794
1795 netdev_for_each_mc_addr(ha, dev) {
1796 writel(*(u32 *)(ha->addr), ioaddr + 0x100 + i*8);
1797 writel(0x20000 | (*(u16 *)&ha->addr[4]),
1798 ioaddr + 0x104 + i*8);
1799 i++;
1800 }
1801
1802 for (; i < 64; i++)
1803 writel(0, ioaddr + 0x104 + i*8);
1804 writew(0x0003, ioaddr + AddrMode);
1805 } else {
1806 writew(0x0001, ioaddr + AddrMode);
1807 }
1808}
1809
1810static int check_if_running(struct net_device *dev)
1811{
1812 if (!netif_running(dev))
1813 return -EINVAL;
1814 return 0;
1815}
1816
1817static void hamachi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1818{
1819 struct hamachi_private *np = netdev_priv(dev);
1820
1821 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1822 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1823 strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1824}
1825
1826static int hamachi_get_link_ksettings(struct net_device *dev,
1827 struct ethtool_link_ksettings *cmd)
1828{
1829 struct hamachi_private *np = netdev_priv(dev);
1830 spin_lock_irq(&np->lock);
1831 mii_ethtool_get_link_ksettings(&np->mii_if, cmd);
1832 spin_unlock_irq(&np->lock);
1833 return 0;
1834}
1835
1836static int hamachi_set_link_ksettings(struct net_device *dev,
1837 const struct ethtool_link_ksettings *cmd)
1838{
1839 struct hamachi_private *np = netdev_priv(dev);
1840 int res;
1841 spin_lock_irq(&np->lock);
1842 res = mii_ethtool_set_link_ksettings(&np->mii_if, cmd);
1843 spin_unlock_irq(&np->lock);
1844 return res;
1845}
1846
1847static int hamachi_nway_reset(struct net_device *dev)
1848{
1849 struct hamachi_private *np = netdev_priv(dev);
1850 return mii_nway_restart(&np->mii_if);
1851}
1852
1853static u32 hamachi_get_link(struct net_device *dev)
1854{
1855 struct hamachi_private *np = netdev_priv(dev);
1856 return mii_link_ok(&np->mii_if);
1857}
1858
1859static const struct ethtool_ops ethtool_ops = {
1860 .begin = check_if_running,
1861 .get_drvinfo = hamachi_get_drvinfo,
1862 .nway_reset = hamachi_nway_reset,
1863 .get_link = hamachi_get_link,
1864 .get_link_ksettings = hamachi_get_link_ksettings,
1865 .set_link_ksettings = hamachi_set_link_ksettings,
1866};
1867
1868static const struct ethtool_ops ethtool_ops_no_mii = {
1869 .begin = check_if_running,
1870 .get_drvinfo = hamachi_get_drvinfo,
1871};
1872
1873
1874static int hamachi_siocdevprivate(struct net_device *dev, struct ifreq *rq,
1875 void __user *data, int cmd)
1876{
1877 struct hamachi_private *np = netdev_priv(dev);
1878 u32 *d = (u32 *)&rq->ifr_ifru;
1879
1880 if (!netif_running(dev))
1881 return -EINVAL;
1882
1883 if (cmd != SIOCDEVPRIVATE + 3)
1884 return -EOPNOTSUPP;
1885
1886
1887
1888
1889
1890
1891 if (!capable(CAP_NET_ADMIN))
1892 return -EPERM;
1893 writel(d[0], np->base + TxIntrCtrl);
1894 writel(d[1], np->base + RxIntrCtrl);
1895 printk(KERN_NOTICE "%s: tx %08x, rx %08x intr\n", dev->name,
1896 (u32)readl(np->base + TxIntrCtrl),
1897 (u32)readl(np->base + RxIntrCtrl));
1898
1899 return 0;
1900}
1901
1902static int hamachi_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1903{
1904 struct hamachi_private *np = netdev_priv(dev);
1905 struct mii_ioctl_data *data = if_mii(rq);
1906 int rc;
1907
1908 if (!netif_running(dev))
1909 return -EINVAL;
1910
1911 spin_lock_irq(&np->lock);
1912 rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
1913 spin_unlock_irq(&np->lock);
1914
1915 return rc;
1916}
1917
1918
1919static void hamachi_remove_one(struct pci_dev *pdev)
1920{
1921 struct net_device *dev = pci_get_drvdata(pdev);
1922
1923 if (dev) {
1924 struct hamachi_private *hmp = netdev_priv(dev);
1925
1926 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
1927 hmp->rx_ring_dma);
1928 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
1929 hmp->tx_ring_dma);
1930 unregister_netdev(dev);
1931 iounmap(hmp->base);
1932 free_netdev(dev);
1933 pci_release_regions(pdev);
1934 }
1935}
1936
1937static const struct pci_device_id hamachi_pci_tbl[] = {
1938 { 0x1318, 0x0911, PCI_ANY_ID, PCI_ANY_ID, },
1939 { 0, }
1940};
1941MODULE_DEVICE_TABLE(pci, hamachi_pci_tbl);
1942
1943static struct pci_driver hamachi_driver = {
1944 .name = DRV_NAME,
1945 .id_table = hamachi_pci_tbl,
1946 .probe = hamachi_init_one,
1947 .remove = hamachi_remove_one,
1948};
1949
1950static int __init hamachi_init (void)
1951{
1952
1953#ifdef MODULE
1954 printk(version);
1955#endif
1956 return pci_register_driver(&hamachi_driver);
1957}
1958
1959static void __exit hamachi_exit (void)
1960{
1961 pci_unregister_driver(&hamachi_driver);
1962}
1963
1964
1965module_init(hamachi_init);
1966module_exit(hamachi_exit);
1967