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#include <linux/compiler.h>
26#include <linux/crc32.h>
27#include <linux/delay.h>
28#include <linux/etherdevice.h>
29#include <linux/ethtool.h>
30#include <linux/firmware.h>
31#include <linux/if_vlan.h>
32#include <linux/in.h>
33#include <linux/init.h>
34#include <linux/interrupt.h>
35#include <linux/gfp.h>
36#include <linux/ioport.h>
37#include <linux/ip.h>
38#include <linux/kernel.h>
39#include <linux/mii.h>
40#include <linux/module.h>
41#include <linux/netdevice.h>
42#include <linux/device.h>
43#include <linux/pci.h>
44#include <linux/skbuff.h>
45#include <linux/tcp.h>
46#include <linux/types.h>
47#include <linux/vmalloc.h>
48#include <linux/wait.h>
49#include <linux/workqueue.h>
50#include <linux/bitops.h>
51#include <net/checksum.h>
52
53#include "spider_net.h"
54
55MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com> and Jens Osterkamp " \
56 "<Jens.Osterkamp@de.ibm.com>");
57MODULE_DESCRIPTION("Spider Southbridge Gigabit Ethernet driver");
58MODULE_LICENSE("GPL");
59MODULE_VERSION(VERSION);
60MODULE_FIRMWARE(SPIDER_NET_FIRMWARE_NAME);
61
62static int rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_DEFAULT;
63static int tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_DEFAULT;
64
65module_param(rx_descriptors, int, 0444);
66module_param(tx_descriptors, int, 0444);
67
68MODULE_PARM_DESC(rx_descriptors, "number of descriptors used " \
69 "in rx chains");
70MODULE_PARM_DESC(tx_descriptors, "number of descriptors used " \
71 "in tx chain");
72
73char spider_net_driver_name[] = "spidernet";
74
75static const struct pci_device_id spider_net_pci_tbl[] = {
76 { PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET,
77 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
78 { 0, }
79};
80
81MODULE_DEVICE_TABLE(pci, spider_net_pci_tbl);
82
83
84
85
86
87
88
89
90static inline u32
91spider_net_read_reg(struct spider_net_card *card, u32 reg)
92{
93
94
95
96
97 return in_be32(card->regs + reg);
98}
99
100
101
102
103
104
105
106static inline void
107spider_net_write_reg(struct spider_net_card *card, u32 reg, u32 value)
108{
109
110
111
112
113 out_be32(card->regs + reg, value);
114}
115
116
117
118
119
120
121
122
123
124
125
126
127static void
128spider_net_write_phy(struct net_device *netdev, int mii_id,
129 int reg, int val)
130{
131 struct spider_net_card *card = netdev_priv(netdev);
132 u32 writevalue;
133
134 writevalue = ((u32)mii_id << 21) |
135 ((u32)reg << 16) | ((u32)val);
136
137 spider_net_write_reg(card, SPIDER_NET_GPCWOPCMD, writevalue);
138}
139
140
141
142
143
144
145
146
147
148
149
150
151static int
152spider_net_read_phy(struct net_device *netdev, int mii_id, int reg)
153{
154 struct spider_net_card *card = netdev_priv(netdev);
155 u32 readvalue;
156
157 readvalue = ((u32)mii_id << 21) | ((u32)reg << 16);
158 spider_net_write_reg(card, SPIDER_NET_GPCROPCMD, readvalue);
159
160
161
162
163 do {
164 readvalue = spider_net_read_reg(card, SPIDER_NET_GPCROPCMD);
165 } while (readvalue & SPIDER_NET_GPREXEC);
166
167 readvalue &= SPIDER_NET_GPRDAT_MASK;
168
169 return readvalue;
170}
171
172
173
174
175
176static void
177spider_net_setup_aneg(struct spider_net_card *card)
178{
179 struct mii_phy *phy = &card->phy;
180 u32 advertise = 0;
181 u16 bmsr, estat;
182
183 bmsr = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR);
184 estat = spider_net_read_phy(card->netdev, phy->mii_id, MII_ESTATUS);
185
186 if (bmsr & BMSR_10HALF)
187 advertise |= ADVERTISED_10baseT_Half;
188 if (bmsr & BMSR_10FULL)
189 advertise |= ADVERTISED_10baseT_Full;
190 if (bmsr & BMSR_100HALF)
191 advertise |= ADVERTISED_100baseT_Half;
192 if (bmsr & BMSR_100FULL)
193 advertise |= ADVERTISED_100baseT_Full;
194
195 if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_TFULL))
196 advertise |= SUPPORTED_1000baseT_Full;
197 if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_THALF))
198 advertise |= SUPPORTED_1000baseT_Half;
199
200 sungem_phy_probe(phy, phy->mii_id);
201 phy->def->ops->setup_aneg(phy, advertise);
202
203}
204
205
206
207
208
209
210
211static void
212spider_net_rx_irq_off(struct spider_net_card *card)
213{
214 u32 regvalue;
215
216 regvalue = SPIDER_NET_INT0_MASK_VALUE & (~SPIDER_NET_RXINT);
217 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue);
218}
219
220
221
222
223
224
225
226static void
227spider_net_rx_irq_on(struct spider_net_card *card)
228{
229 u32 regvalue;
230
231 regvalue = SPIDER_NET_INT0_MASK_VALUE | SPIDER_NET_RXINT;
232 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue);
233}
234
235
236
237
238
239
240
241
242static void
243spider_net_set_promisc(struct spider_net_card *card)
244{
245 u32 macu, macl;
246 struct net_device *netdev = card->netdev;
247
248 if (netdev->flags & IFF_PROMISC) {
249
250 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, 0);
251 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, 0);
252 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
253 SPIDER_NET_PROMISC_VALUE);
254 } else {
255 macu = netdev->dev_addr[0];
256 macu <<= 8;
257 macu |= netdev->dev_addr[1];
258 memcpy(&macl, &netdev->dev_addr[2], sizeof(macl));
259
260 macu |= SPIDER_NET_UA_DESCR_VALUE;
261 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, macu);
262 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, macl);
263 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
264 SPIDER_NET_NONPROMISC_VALUE);
265 }
266}
267
268
269
270
271
272
273
274static inline int
275spider_net_get_descr_status(struct spider_net_hw_descr *hwdescr)
276{
277 return hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_IND_PROC_MASK;
278}
279
280
281
282
283
284
285
286static void
287spider_net_free_chain(struct spider_net_card *card,
288 struct spider_net_descr_chain *chain)
289{
290 struct spider_net_descr *descr;
291
292 descr = chain->ring;
293 do {
294 descr->bus_addr = 0;
295 descr->hwdescr->next_descr_addr = 0;
296 descr = descr->next;
297 } while (descr != chain->ring);
298
299 dma_free_coherent(&card->pdev->dev, chain->num_desc,
300 chain->hwring, chain->dma_addr);
301}
302
303
304
305
306
307
308
309
310
311
312
313static int
314spider_net_init_chain(struct spider_net_card *card,
315 struct spider_net_descr_chain *chain)
316{
317 int i;
318 struct spider_net_descr *descr;
319 struct spider_net_hw_descr *hwdescr;
320 dma_addr_t buf;
321 size_t alloc_size;
322
323 alloc_size = chain->num_desc * sizeof(struct spider_net_hw_descr);
324
325 chain->hwring = dma_alloc_coherent(&card->pdev->dev, alloc_size,
326 &chain->dma_addr, GFP_KERNEL);
327 if (!chain->hwring)
328 return -ENOMEM;
329
330 memset(chain->ring, 0, chain->num_desc * sizeof(struct spider_net_descr));
331
332
333 descr = chain->ring;
334 hwdescr = chain->hwring;
335 buf = chain->dma_addr;
336 for (i=0; i < chain->num_desc; i++, descr++, hwdescr++) {
337 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
338 hwdescr->next_descr_addr = 0;
339
340 descr->hwdescr = hwdescr;
341 descr->bus_addr = buf;
342 descr->next = descr + 1;
343 descr->prev = descr - 1;
344
345 buf += sizeof(struct spider_net_hw_descr);
346 }
347
348 (descr-1)->next = chain->ring;
349 chain->ring->prev = descr-1;
350
351 spin_lock_init(&chain->lock);
352 chain->head = chain->ring;
353 chain->tail = chain->ring;
354 return 0;
355}
356
357
358
359
360
361
362
363static void
364spider_net_free_rx_chain_contents(struct spider_net_card *card)
365{
366 struct spider_net_descr *descr;
367
368 descr = card->rx_chain.head;
369 do {
370 if (descr->skb) {
371 pci_unmap_single(card->pdev, descr->hwdescr->buf_addr,
372 SPIDER_NET_MAX_FRAME,
373 PCI_DMA_BIDIRECTIONAL);
374 dev_kfree_skb(descr->skb);
375 descr->skb = NULL;
376 }
377 descr = descr->next;
378 } while (descr != card->rx_chain.head);
379}
380
381
382
383
384
385
386
387
388
389
390
391static int
392spider_net_prepare_rx_descr(struct spider_net_card *card,
393 struct spider_net_descr *descr)
394{
395 struct spider_net_hw_descr *hwdescr = descr->hwdescr;
396 dma_addr_t buf;
397 int offset;
398 int bufsize;
399
400
401 bufsize = (SPIDER_NET_MAX_FRAME + SPIDER_NET_RXBUF_ALIGN - 1) &
402 (~(SPIDER_NET_RXBUF_ALIGN - 1));
403
404
405
406
407 descr->skb = netdev_alloc_skb(card->netdev,
408 bufsize + SPIDER_NET_RXBUF_ALIGN - 1);
409 if (!descr->skb) {
410 if (netif_msg_rx_err(card) && net_ratelimit())
411 dev_err(&card->netdev->dev,
412 "Not enough memory to allocate rx buffer\n");
413 card->spider_stats.alloc_rx_skb_error++;
414 return -ENOMEM;
415 }
416 hwdescr->buf_size = bufsize;
417 hwdescr->result_size = 0;
418 hwdescr->valid_size = 0;
419 hwdescr->data_status = 0;
420 hwdescr->data_error = 0;
421
422 offset = ((unsigned long)descr->skb->data) &
423 (SPIDER_NET_RXBUF_ALIGN - 1);
424 if (offset)
425 skb_reserve(descr->skb, SPIDER_NET_RXBUF_ALIGN - offset);
426
427 buf = pci_map_single(card->pdev, descr->skb->data,
428 SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE);
429 if (pci_dma_mapping_error(card->pdev, buf)) {
430 dev_kfree_skb_any(descr->skb);
431 descr->skb = NULL;
432 if (netif_msg_rx_err(card) && net_ratelimit())
433 dev_err(&card->netdev->dev, "Could not iommu-map rx buffer\n");
434 card->spider_stats.rx_iommu_map_error++;
435 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
436 } else {
437 hwdescr->buf_addr = buf;
438 wmb();
439 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_CARDOWNED |
440 SPIDER_NET_DMAC_NOINTR_COMPLETE;
441 }
442
443 return 0;
444}
445
446
447
448
449
450
451
452
453
454static inline void
455spider_net_enable_rxchtails(struct spider_net_card *card)
456{
457
458 spider_net_write_reg(card, SPIDER_NET_GDADCHA ,
459 card->rx_chain.tail->bus_addr);
460}
461
462
463
464
465
466
467
468
469static inline void
470spider_net_enable_rxdmac(struct spider_net_card *card)
471{
472 wmb();
473 spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
474 SPIDER_NET_DMA_RX_VALUE);
475}
476
477
478
479
480
481
482
483
484static inline void
485spider_net_disable_rxdmac(struct spider_net_card *card)
486{
487 spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
488 SPIDER_NET_DMA_RX_FEND_VALUE);
489}
490
491
492
493
494
495
496
497static void
498spider_net_refill_rx_chain(struct spider_net_card *card)
499{
500 struct spider_net_descr_chain *chain = &card->rx_chain;
501 unsigned long flags;
502
503
504
505
506
507 if (!spin_trylock_irqsave(&chain->lock, flags))
508 return;
509
510 while (spider_net_get_descr_status(chain->head->hwdescr) ==
511 SPIDER_NET_DESCR_NOT_IN_USE) {
512 if (spider_net_prepare_rx_descr(card, chain->head))
513 break;
514 chain->head = chain->head->next;
515 }
516
517 spin_unlock_irqrestore(&chain->lock, flags);
518}
519
520
521
522
523
524
525
526static int
527spider_net_alloc_rx_skbs(struct spider_net_card *card)
528{
529 struct spider_net_descr_chain *chain = &card->rx_chain;
530 struct spider_net_descr *start = chain->tail;
531 struct spider_net_descr *descr = start;
532
533
534 do {
535 descr->prev->hwdescr->next_descr_addr = descr->bus_addr;
536 descr = descr->next;
537 } while (descr != start);
538
539
540
541
542 if (spider_net_prepare_rx_descr(card, chain->head))
543 goto error;
544 else
545 chain->head = chain->head->next;
546
547
548
549 spider_net_refill_rx_chain(card);
550 spider_net_enable_rxdmac(card);
551 return 0;
552
553error:
554 spider_net_free_rx_chain_contents(card);
555 return -ENOMEM;
556}
557
558
559
560
561
562
563
564
565
566
567static u8
568spider_net_get_multicast_hash(struct net_device *netdev, __u8 *addr)
569{
570 u32 crc;
571 u8 hash;
572 char addr_for_crc[ETH_ALEN] = { 0, };
573 int i, bit;
574
575 for (i = 0; i < ETH_ALEN * 8; i++) {
576 bit = (addr[i / 8] >> (i % 8)) & 1;
577 addr_for_crc[ETH_ALEN - 1 - i / 8] += bit << (7 - (i % 8));
578 }
579
580 crc = crc32_be(~0, addr_for_crc, netdev->addr_len);
581
582 hash = (crc >> 27);
583 hash <<= 3;
584 hash |= crc & 7;
585 hash &= 0xff;
586
587 return hash;
588}
589
590
591
592
593
594
595
596
597
598static void
599spider_net_set_multi(struct net_device *netdev)
600{
601 struct netdev_hw_addr *ha;
602 u8 hash;
603 int i;
604 u32 reg;
605 struct spider_net_card *card = netdev_priv(netdev);
606 DECLARE_BITMAP(bitmask, SPIDER_NET_MULTICAST_HASHES) = {};
607
608 spider_net_set_promisc(card);
609
610 if (netdev->flags & IFF_ALLMULTI) {
611 for (i = 0; i < SPIDER_NET_MULTICAST_HASHES; i++) {
612 set_bit(i, bitmask);
613 }
614 goto write_hash;
615 }
616
617
618
619 set_bit(0xfd, bitmask);
620
621 netdev_for_each_mc_addr(ha, netdev) {
622 hash = spider_net_get_multicast_hash(netdev, ha->addr);
623 set_bit(hash, bitmask);
624 }
625
626write_hash:
627 for (i = 0; i < SPIDER_NET_MULTICAST_HASHES / 4; i++) {
628 reg = 0;
629 if (test_bit(i * 4, bitmask))
630 reg += 0x08;
631 reg <<= 8;
632 if (test_bit(i * 4 + 1, bitmask))
633 reg += 0x08;
634 reg <<= 8;
635 if (test_bit(i * 4 + 2, bitmask))
636 reg += 0x08;
637 reg <<= 8;
638 if (test_bit(i * 4 + 3, bitmask))
639 reg += 0x08;
640
641 spider_net_write_reg(card, SPIDER_NET_GMRMHFILnR + i * 4, reg);
642 }
643}
644
645
646
647
648
649
650
651
652
653
654
655static int
656spider_net_prepare_tx_descr(struct spider_net_card *card,
657 struct sk_buff *skb)
658{
659 struct spider_net_descr_chain *chain = &card->tx_chain;
660 struct spider_net_descr *descr;
661 struct spider_net_hw_descr *hwdescr;
662 dma_addr_t buf;
663 unsigned long flags;
664
665 buf = pci_map_single(card->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
666 if (pci_dma_mapping_error(card->pdev, buf)) {
667 if (netif_msg_tx_err(card) && net_ratelimit())
668 dev_err(&card->netdev->dev, "could not iommu-map packet (%p, %i). "
669 "Dropping packet\n", skb->data, skb->len);
670 card->spider_stats.tx_iommu_map_error++;
671 return -ENOMEM;
672 }
673
674 spin_lock_irqsave(&chain->lock, flags);
675 descr = card->tx_chain.head;
676 if (descr->next == chain->tail->prev) {
677 spin_unlock_irqrestore(&chain->lock, flags);
678 pci_unmap_single(card->pdev, buf, skb->len, PCI_DMA_TODEVICE);
679 return -ENOMEM;
680 }
681 hwdescr = descr->hwdescr;
682 chain->head = descr->next;
683
684 descr->skb = skb;
685 hwdescr->buf_addr = buf;
686 hwdescr->buf_size = skb->len;
687 hwdescr->next_descr_addr = 0;
688 hwdescr->data_status = 0;
689
690 hwdescr->dmac_cmd_status =
691 SPIDER_NET_DESCR_CARDOWNED | SPIDER_NET_DMAC_TXFRMTL;
692 spin_unlock_irqrestore(&chain->lock, flags);
693
694 if (skb->ip_summed == CHECKSUM_PARTIAL)
695 switch (ip_hdr(skb)->protocol) {
696 case IPPROTO_TCP:
697 hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_TCP;
698 break;
699 case IPPROTO_UDP:
700 hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_UDP;
701 break;
702 }
703
704
705 wmb();
706 descr->prev->hwdescr->next_descr_addr = descr->bus_addr;
707
708 netif_trans_update(card->netdev);
709 return 0;
710}
711
712static int
713spider_net_set_low_watermark(struct spider_net_card *card)
714{
715 struct spider_net_descr *descr = card->tx_chain.tail;
716 struct spider_net_hw_descr *hwdescr;
717 unsigned long flags;
718 int status;
719 int cnt=0;
720 int i;
721
722
723
724 while (descr != card->tx_chain.head) {
725 status = descr->hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_NOT_IN_USE;
726 if (status == SPIDER_NET_DESCR_NOT_IN_USE)
727 break;
728 descr = descr->next;
729 cnt++;
730 }
731
732
733 if (cnt < card->tx_chain.num_desc/4)
734 return cnt;
735
736
737 descr = card->tx_chain.tail;
738 cnt = (cnt*3)/4;
739 for (i=0;i<cnt; i++)
740 descr = descr->next;
741
742
743 spin_lock_irqsave(&card->tx_chain.lock, flags);
744 descr->hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_TXDESFLG;
745 if (card->low_watermark && card->low_watermark != descr) {
746 hwdescr = card->low_watermark->hwdescr;
747 hwdescr->dmac_cmd_status =
748 hwdescr->dmac_cmd_status & ~SPIDER_NET_DESCR_TXDESFLG;
749 }
750 card->low_watermark = descr;
751 spin_unlock_irqrestore(&card->tx_chain.lock, flags);
752 return cnt;
753}
754
755
756
757
758
759
760
761
762
763
764
765
766
767static int
768spider_net_release_tx_chain(struct spider_net_card *card, int brutal)
769{
770 struct net_device *dev = card->netdev;
771 struct spider_net_descr_chain *chain = &card->tx_chain;
772 struct spider_net_descr *descr;
773 struct spider_net_hw_descr *hwdescr;
774 struct sk_buff *skb;
775 u32 buf_addr;
776 unsigned long flags;
777 int status;
778
779 while (1) {
780 spin_lock_irqsave(&chain->lock, flags);
781 if (chain->tail == chain->head) {
782 spin_unlock_irqrestore(&chain->lock, flags);
783 return 0;
784 }
785 descr = chain->tail;
786 hwdescr = descr->hwdescr;
787
788 status = spider_net_get_descr_status(hwdescr);
789 switch (status) {
790 case SPIDER_NET_DESCR_COMPLETE:
791 dev->stats.tx_packets++;
792 dev->stats.tx_bytes += descr->skb->len;
793 break;
794
795 case SPIDER_NET_DESCR_CARDOWNED:
796 if (!brutal) {
797 spin_unlock_irqrestore(&chain->lock, flags);
798 return 1;
799 }
800
801
802
803
804
805 case SPIDER_NET_DESCR_RESPONSE_ERROR:
806 case SPIDER_NET_DESCR_PROTECTION_ERROR:
807 case SPIDER_NET_DESCR_FORCE_END:
808 if (netif_msg_tx_err(card))
809 dev_err(&card->netdev->dev, "forcing end of tx descriptor "
810 "with status x%02x\n", status);
811 dev->stats.tx_errors++;
812 break;
813
814 default:
815 dev->stats.tx_dropped++;
816 if (!brutal) {
817 spin_unlock_irqrestore(&chain->lock, flags);
818 return 1;
819 }
820 }
821
822 chain->tail = descr->next;
823 hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_NOT_IN_USE;
824 skb = descr->skb;
825 descr->skb = NULL;
826 buf_addr = hwdescr->buf_addr;
827 spin_unlock_irqrestore(&chain->lock, flags);
828
829
830 if (skb) {
831 pci_unmap_single(card->pdev, buf_addr, skb->len,
832 PCI_DMA_TODEVICE);
833 dev_consume_skb_any(skb);
834 }
835 }
836 return 0;
837}
838
839
840
841
842
843
844
845
846
847
848
849
850static inline void
851spider_net_kick_tx_dma(struct spider_net_card *card)
852{
853 struct spider_net_descr *descr;
854
855 if (spider_net_read_reg(card, SPIDER_NET_GDTDMACCNTR) &
856 SPIDER_NET_TX_DMA_EN)
857 goto out;
858
859 descr = card->tx_chain.tail;
860 for (;;) {
861 if (spider_net_get_descr_status(descr->hwdescr) ==
862 SPIDER_NET_DESCR_CARDOWNED) {
863 spider_net_write_reg(card, SPIDER_NET_GDTDCHA,
864 descr->bus_addr);
865 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
866 SPIDER_NET_DMA_TX_VALUE);
867 break;
868 }
869 if (descr == card->tx_chain.head)
870 break;
871 descr = descr->next;
872 }
873
874out:
875 mod_timer(&card->tx_timer, jiffies + SPIDER_NET_TX_TIMER);
876}
877
878
879
880
881
882
883
884
885static int
886spider_net_xmit(struct sk_buff *skb, struct net_device *netdev)
887{
888 int cnt;
889 struct spider_net_card *card = netdev_priv(netdev);
890
891 spider_net_release_tx_chain(card, 0);
892
893 if (spider_net_prepare_tx_descr(card, skb) != 0) {
894 netdev->stats.tx_dropped++;
895 netif_stop_queue(netdev);
896 return NETDEV_TX_BUSY;
897 }
898
899 cnt = spider_net_set_low_watermark(card);
900 if (cnt < 5)
901 spider_net_kick_tx_dma(card);
902 return NETDEV_TX_OK;
903}
904
905
906
907
908
909
910
911
912
913
914static void
915spider_net_cleanup_tx_ring(struct spider_net_card *card)
916{
917 if ((spider_net_release_tx_chain(card, 0) != 0) &&
918 (card->netdev->flags & IFF_UP)) {
919 spider_net_kick_tx_dma(card);
920 netif_wake_queue(card->netdev);
921 }
922}
923
924
925
926
927
928
929
930
931
932
933static int
934spider_net_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
935{
936 switch (cmd) {
937 default:
938 return -EOPNOTSUPP;
939 }
940}
941
942
943
944
945
946
947
948
949
950static void
951spider_net_pass_skb_up(struct spider_net_descr *descr,
952 struct spider_net_card *card)
953{
954 struct spider_net_hw_descr *hwdescr = descr->hwdescr;
955 struct sk_buff *skb = descr->skb;
956 struct net_device *netdev = card->netdev;
957 u32 data_status = hwdescr->data_status;
958 u32 data_error = hwdescr->data_error;
959
960 skb_put(skb, hwdescr->valid_size);
961
962
963
964#define SPIDER_MISALIGN 2
965 skb_pull(skb, SPIDER_MISALIGN);
966 skb->protocol = eth_type_trans(skb, netdev);
967
968
969 skb_checksum_none_assert(skb);
970 if (netdev->features & NETIF_F_RXCSUM) {
971 if ( ( (data_status & SPIDER_NET_DATA_STATUS_CKSUM_MASK) ==
972 SPIDER_NET_DATA_STATUS_CKSUM_MASK) &&
973 !(data_error & SPIDER_NET_DATA_ERR_CKSUM_MASK))
974 skb->ip_summed = CHECKSUM_UNNECESSARY;
975 }
976
977 if (data_status & SPIDER_NET_VLAN_PACKET) {
978
979 }
980
981
982 netdev->stats.rx_packets++;
983 netdev->stats.rx_bytes += skb->len;
984
985
986 netif_receive_skb(skb);
987}
988
989static void show_rx_chain(struct spider_net_card *card)
990{
991 struct spider_net_descr_chain *chain = &card->rx_chain;
992 struct spider_net_descr *start= chain->tail;
993 struct spider_net_descr *descr= start;
994 struct spider_net_hw_descr *hwd = start->hwdescr;
995 struct device *dev = &card->netdev->dev;
996 u32 curr_desc, next_desc;
997 int status;
998
999 int tot = 0;
1000 int cnt = 0;
1001 int off = start - chain->ring;
1002 int cstat = hwd->dmac_cmd_status;
1003
1004 dev_info(dev, "Total number of descrs=%d\n",
1005 chain->num_desc);
1006 dev_info(dev, "Chain tail located at descr=%d, status=0x%x\n",
1007 off, cstat);
1008
1009 curr_desc = spider_net_read_reg(card, SPIDER_NET_GDACTDPA);
1010 next_desc = spider_net_read_reg(card, SPIDER_NET_GDACNEXTDA);
1011
1012 status = cstat;
1013 do
1014 {
1015 hwd = descr->hwdescr;
1016 off = descr - chain->ring;
1017 status = hwd->dmac_cmd_status;
1018
1019 if (descr == chain->head)
1020 dev_info(dev, "Chain head is at %d, head status=0x%x\n",
1021 off, status);
1022
1023 if (curr_desc == descr->bus_addr)
1024 dev_info(dev, "HW curr desc (GDACTDPA) is at %d, status=0x%x\n",
1025 off, status);
1026
1027 if (next_desc == descr->bus_addr)
1028 dev_info(dev, "HW next desc (GDACNEXTDA) is at %d, status=0x%x\n",
1029 off, status);
1030
1031 if (hwd->next_descr_addr == 0)
1032 dev_info(dev, "chain is cut at %d\n", off);
1033
1034 if (cstat != status) {
1035 int from = (chain->num_desc + off - cnt) % chain->num_desc;
1036 int to = (chain->num_desc + off - 1) % chain->num_desc;
1037 dev_info(dev, "Have %d (from %d to %d) descrs "
1038 "with stat=0x%08x\n", cnt, from, to, cstat);
1039 cstat = status;
1040 cnt = 0;
1041 }
1042
1043 cnt ++;
1044 tot ++;
1045 descr = descr->next;
1046 } while (descr != start);
1047
1048 dev_info(dev, "Last %d descrs with stat=0x%08x "
1049 "for a total of %d descrs\n", cnt, cstat, tot);
1050
1051#ifdef DEBUG
1052
1053 descr = start;
1054 do
1055 {
1056 struct spider_net_hw_descr *hwd = descr->hwdescr;
1057 status = spider_net_get_descr_status(hwd);
1058 cnt = descr - chain->ring;
1059 dev_info(dev, "Descr %d stat=0x%08x skb=%p\n",
1060 cnt, status, descr->skb);
1061 dev_info(dev, "bus addr=%08x buf addr=%08x sz=%d\n",
1062 descr->bus_addr, hwd->buf_addr, hwd->buf_size);
1063 dev_info(dev, "next=%08x result sz=%d valid sz=%d\n",
1064 hwd->next_descr_addr, hwd->result_size,
1065 hwd->valid_size);
1066 dev_info(dev, "dmac=%08x data stat=%08x data err=%08x\n",
1067 hwd->dmac_cmd_status, hwd->data_status,
1068 hwd->data_error);
1069 dev_info(dev, "\n");
1070
1071 descr = descr->next;
1072 } while (descr != start);
1073#endif
1074
1075}
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086static void spider_net_resync_head_ptr(struct spider_net_card *card)
1087{
1088 unsigned long flags;
1089 struct spider_net_descr_chain *chain = &card->rx_chain;
1090 struct spider_net_descr *descr;
1091 int i, status;
1092
1093
1094 descr = chain->head;
1095 status = spider_net_get_descr_status(descr->hwdescr);
1096
1097 if (status == SPIDER_NET_DESCR_NOT_IN_USE)
1098 return;
1099
1100 spin_lock_irqsave(&chain->lock, flags);
1101
1102 descr = chain->head;
1103 status = spider_net_get_descr_status(descr->hwdescr);
1104 for (i=0; i<chain->num_desc; i++) {
1105 if (status != SPIDER_NET_DESCR_CARDOWNED) break;
1106 descr = descr->next;
1107 status = spider_net_get_descr_status(descr->hwdescr);
1108 }
1109 chain->head = descr;
1110
1111 spin_unlock_irqrestore(&chain->lock, flags);
1112}
1113
1114static int spider_net_resync_tail_ptr(struct spider_net_card *card)
1115{
1116 struct spider_net_descr_chain *chain = &card->rx_chain;
1117 struct spider_net_descr *descr;
1118 int i, status;
1119
1120
1121 descr = chain->tail;
1122 status = spider_net_get_descr_status(descr->hwdescr);
1123
1124 for (i=0; i<chain->num_desc; i++) {
1125 if ((status != SPIDER_NET_DESCR_CARDOWNED) &&
1126 (status != SPIDER_NET_DESCR_NOT_IN_USE)) break;
1127 descr = descr->next;
1128 status = spider_net_get_descr_status(descr->hwdescr);
1129 }
1130 chain->tail = descr;
1131
1132 if ((i == chain->num_desc) || (i == 0))
1133 return 1;
1134 return 0;
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148static int
1149spider_net_decode_one_descr(struct spider_net_card *card)
1150{
1151 struct net_device *dev = card->netdev;
1152 struct spider_net_descr_chain *chain = &card->rx_chain;
1153 struct spider_net_descr *descr = chain->tail;
1154 struct spider_net_hw_descr *hwdescr = descr->hwdescr;
1155 u32 hw_buf_addr;
1156 int status;
1157
1158 status = spider_net_get_descr_status(hwdescr);
1159
1160
1161 if ((status == SPIDER_NET_DESCR_CARDOWNED) ||
1162 (status == SPIDER_NET_DESCR_NOT_IN_USE))
1163 return 0;
1164
1165
1166 chain->tail = descr->next;
1167
1168
1169 hw_buf_addr = hwdescr->buf_addr;
1170 hwdescr->buf_addr = 0xffffffff;
1171 pci_unmap_single(card->pdev, hw_buf_addr,
1172 SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE);
1173
1174 if ( (status == SPIDER_NET_DESCR_RESPONSE_ERROR) ||
1175 (status == SPIDER_NET_DESCR_PROTECTION_ERROR) ||
1176 (status == SPIDER_NET_DESCR_FORCE_END) ) {
1177 if (netif_msg_rx_err(card))
1178 dev_err(&dev->dev,
1179 "dropping RX descriptor with state %d\n", status);
1180 dev->stats.rx_dropped++;
1181 goto bad_desc;
1182 }
1183
1184 if ( (status != SPIDER_NET_DESCR_COMPLETE) &&
1185 (status != SPIDER_NET_DESCR_FRAME_END) ) {
1186 if (netif_msg_rx_err(card))
1187 dev_err(&card->netdev->dev,
1188 "RX descriptor with unknown state %d\n", status);
1189 card->spider_stats.rx_desc_unk_state++;
1190 goto bad_desc;
1191 }
1192
1193
1194 if (hwdescr->data_error & SPIDER_NET_DESTROY_RX_FLAGS) {
1195 if (netif_msg_rx_err(card))
1196 dev_err(&card->netdev->dev,
1197 "error in received descriptor found, "
1198 "data_status=x%08x, data_error=x%08x\n",
1199 hwdescr->data_status, hwdescr->data_error);
1200 goto bad_desc;
1201 }
1202
1203 if (hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_BAD_STATUS) {
1204 dev_err(&card->netdev->dev, "bad status, cmd_status=x%08x\n",
1205 hwdescr->dmac_cmd_status);
1206 pr_err("buf_addr=x%08x\n", hw_buf_addr);
1207 pr_err("buf_size=x%08x\n", hwdescr->buf_size);
1208 pr_err("next_descr_addr=x%08x\n", hwdescr->next_descr_addr);
1209 pr_err("result_size=x%08x\n", hwdescr->result_size);
1210 pr_err("valid_size=x%08x\n", hwdescr->valid_size);
1211 pr_err("data_status=x%08x\n", hwdescr->data_status);
1212 pr_err("data_error=x%08x\n", hwdescr->data_error);
1213 pr_err("which=%ld\n", descr - card->rx_chain.ring);
1214
1215 card->spider_stats.rx_desc_error++;
1216 goto bad_desc;
1217 }
1218
1219
1220 spider_net_pass_skb_up(descr, card);
1221 descr->skb = NULL;
1222 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
1223 return 1;
1224
1225bad_desc:
1226 if (netif_msg_rx_err(card))
1227 show_rx_chain(card);
1228 dev_kfree_skb_irq(descr->skb);
1229 descr->skb = NULL;
1230 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
1231 return 0;
1232}
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246static int spider_net_poll(struct napi_struct *napi, int budget)
1247{
1248 struct spider_net_card *card = container_of(napi, struct spider_net_card, napi);
1249 int packets_done = 0;
1250
1251 while (packets_done < budget) {
1252 if (!spider_net_decode_one_descr(card))
1253 break;
1254
1255 packets_done++;
1256 }
1257
1258 if ((packets_done == 0) && (card->num_rx_ints != 0)) {
1259 if (!spider_net_resync_tail_ptr(card))
1260 packets_done = budget;
1261 spider_net_resync_head_ptr(card);
1262 }
1263 card->num_rx_ints = 0;
1264
1265 spider_net_refill_rx_chain(card);
1266 spider_net_enable_rxdmac(card);
1267
1268 spider_net_cleanup_tx_ring(card);
1269
1270
1271
1272 if (packets_done < budget) {
1273 napi_complete_done(napi, packets_done);
1274 spider_net_rx_irq_on(card);
1275 card->ignore_rx_ramfull = 0;
1276 }
1277
1278 return packets_done;
1279}
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289static int
1290spider_net_set_mac(struct net_device *netdev, void *p)
1291{
1292 struct spider_net_card *card = netdev_priv(netdev);
1293 u32 macl, macu, regvalue;
1294 struct sockaddr *addr = p;
1295
1296 if (!is_valid_ether_addr(addr->sa_data))
1297 return -EADDRNOTAVAIL;
1298
1299 memcpy(netdev->dev_addr, addr->sa_data, ETH_ALEN);
1300
1301
1302 regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD);
1303 regvalue &= ~((1 << 5) | (1 << 6));
1304 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue);
1305
1306
1307 macu = (netdev->dev_addr[0]<<24) + (netdev->dev_addr[1]<<16) +
1308 (netdev->dev_addr[2]<<8) + (netdev->dev_addr[3]);
1309 macl = (netdev->dev_addr[4]<<8) + (netdev->dev_addr[5]);
1310 spider_net_write_reg(card, SPIDER_NET_GMACUNIMACU, macu);
1311 spider_net_write_reg(card, SPIDER_NET_GMACUNIMACL, macl);
1312
1313
1314 regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD);
1315 regvalue |= ((1 << 5) | (1 << 6));
1316 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue);
1317
1318 spider_net_set_promisc(card);
1319
1320 return 0;
1321}
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331static void
1332spider_net_link_reset(struct net_device *netdev)
1333{
1334
1335 struct spider_net_card *card = netdev_priv(netdev);
1336
1337 del_timer_sync(&card->aneg_timer);
1338
1339
1340 spider_net_write_reg(card, SPIDER_NET_GMACST,
1341 spider_net_read_reg(card, SPIDER_NET_GMACST));
1342 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0);
1343
1344
1345 card->aneg_count = 0;
1346 card->medium = BCM54XX_COPPER;
1347 spider_net_setup_aneg(card);
1348 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER);
1349
1350}
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360static void
1361spider_net_handle_error_irq(struct spider_net_card *card, u32 status_reg,
1362 u32 error_reg1, u32 error_reg2)
1363{
1364 u32 i;
1365 int show_error = 1;
1366
1367
1368 if (status_reg)
1369 for (i = 0; i < 32; i++)
1370 if (status_reg & (1<<i))
1371 switch (i)
1372 {
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382 case SPIDER_NET_GIPSINT:
1383 show_error = 0;
1384 break;
1385
1386 case SPIDER_NET_GPWOPCMPINT:
1387
1388 show_error = 0;
1389 break;
1390 case SPIDER_NET_GPROPCMPINT:
1391
1392
1393
1394
1395 show_error = 0;
1396 break;
1397 case SPIDER_NET_GPWFFINT:
1398
1399 if (netif_msg_intr(card))
1400 dev_err(&card->netdev->dev, "PHY write queue full\n");
1401 show_error = 0;
1402 break;
1403
1404
1405
1406
1407
1408 case SPIDER_NET_GDTDEN0INT:
1409
1410 show_error = 0;
1411 break;
1412
1413 case SPIDER_NET_GDDDEN0INT:
1414 case SPIDER_NET_GDCDEN0INT:
1415 case SPIDER_NET_GDBDEN0INT:
1416 case SPIDER_NET_GDADEN0INT:
1417
1418 show_error = 0;
1419 break;
1420
1421
1422 case SPIDER_NET_GDDFDCINT:
1423 case SPIDER_NET_GDCFDCINT:
1424 case SPIDER_NET_GDBFDCINT:
1425 case SPIDER_NET_GDAFDCINT:
1426
1427
1428
1429
1430
1431 show_error = 0;
1432 break;
1433
1434
1435 case SPIDER_NET_GDTFDCINT:
1436 show_error = 0;
1437 break;
1438 case SPIDER_NET_GTTEDINT:
1439 show_error = 0;
1440 break;
1441 case SPIDER_NET_GDTDCEINT:
1442
1443
1444
1445
1446
1447 show_error = 0;
1448 break;
1449
1450
1451
1452 }
1453
1454
1455 if (error_reg1)
1456 for (i = 0; i < 32; i++)
1457 if (error_reg1 & (1<<i))
1458 switch (i)
1459 {
1460 case SPIDER_NET_GTMFLLINT:
1461
1462
1463 show_error = 0;
1464 break;
1465 case SPIDER_NET_GRFDFLLINT:
1466 case SPIDER_NET_GRFCFLLINT:
1467 case SPIDER_NET_GRFBFLLINT:
1468 case SPIDER_NET_GRFAFLLINT:
1469 case SPIDER_NET_GRMFLLINT:
1470
1471 if (card->ignore_rx_ramfull == 0) {
1472 card->ignore_rx_ramfull = 1;
1473 spider_net_resync_head_ptr(card);
1474 spider_net_refill_rx_chain(card);
1475 spider_net_enable_rxdmac(card);
1476 card->num_rx_ints ++;
1477 napi_schedule(&card->napi);
1478 }
1479 show_error = 0;
1480 break;
1481
1482
1483 case SPIDER_NET_GDTINVDINT:
1484
1485 show_error = 0;
1486 break;
1487
1488
1489 case SPIDER_NET_GDDDCEINT:
1490 case SPIDER_NET_GDCDCEINT:
1491 case SPIDER_NET_GDBDCEINT:
1492 case SPIDER_NET_GDADCEINT:
1493 spider_net_resync_head_ptr(card);
1494 spider_net_refill_rx_chain(card);
1495 spider_net_enable_rxdmac(card);
1496 card->num_rx_ints ++;
1497 napi_schedule(&card->napi);
1498 show_error = 0;
1499 break;
1500
1501
1502 case SPIDER_NET_GDDINVDINT:
1503 case SPIDER_NET_GDCINVDINT:
1504 case SPIDER_NET_GDBINVDINT:
1505 case SPIDER_NET_GDAINVDINT:
1506
1507 spider_net_resync_head_ptr(card);
1508 spider_net_refill_rx_chain(card);
1509 spider_net_enable_rxdmac(card);
1510 card->num_rx_ints ++;
1511 napi_schedule(&card->napi);
1512 show_error = 0;
1513 break;
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526 default:
1527 show_error = 1;
1528 break;
1529 }
1530
1531
1532 if (error_reg2)
1533 for (i = 0; i < 32; i++)
1534 if (error_reg2 & (1<<i))
1535 switch (i)
1536 {
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562 default:
1563 break;
1564 }
1565
1566 if ((show_error) && (netif_msg_intr(card)) && net_ratelimit())
1567 dev_err(&card->netdev->dev, "Error interrupt, GHIINT0STS = 0x%08x, "
1568 "GHIINT1STS = 0x%08x, GHIINT2STS = 0x%08x\n",
1569 status_reg, error_reg1, error_reg2);
1570
1571
1572 spider_net_write_reg(card, SPIDER_NET_GHIINT1STS, error_reg1);
1573 spider_net_write_reg(card, SPIDER_NET_GHIINT2STS, error_reg2);
1574}
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587static irqreturn_t
1588spider_net_interrupt(int irq, void *ptr)
1589{
1590 struct net_device *netdev = ptr;
1591 struct spider_net_card *card = netdev_priv(netdev);
1592 u32 status_reg, error_reg1, error_reg2;
1593
1594 status_reg = spider_net_read_reg(card, SPIDER_NET_GHIINT0STS);
1595 error_reg1 = spider_net_read_reg(card, SPIDER_NET_GHIINT1STS);
1596 error_reg2 = spider_net_read_reg(card, SPIDER_NET_GHIINT2STS);
1597
1598 if (!(status_reg & SPIDER_NET_INT0_MASK_VALUE) &&
1599 !(error_reg1 & SPIDER_NET_INT1_MASK_VALUE) &&
1600 !(error_reg2 & SPIDER_NET_INT2_MASK_VALUE))
1601 return IRQ_NONE;
1602
1603 if (status_reg & SPIDER_NET_RXINT ) {
1604 spider_net_rx_irq_off(card);
1605 napi_schedule(&card->napi);
1606 card->num_rx_ints ++;
1607 }
1608 if (status_reg & SPIDER_NET_TXINT)
1609 napi_schedule(&card->napi);
1610
1611 if (status_reg & SPIDER_NET_LINKINT)
1612 spider_net_link_reset(netdev);
1613
1614 if (status_reg & SPIDER_NET_ERRINT )
1615 spider_net_handle_error_irq(card, status_reg,
1616 error_reg1, error_reg2);
1617
1618
1619 spider_net_write_reg(card, SPIDER_NET_GHIINT0STS, status_reg);
1620
1621 return IRQ_HANDLED;
1622}
1623
1624#ifdef CONFIG_NET_POLL_CONTROLLER
1625
1626
1627
1628
1629
1630
1631static void
1632spider_net_poll_controller(struct net_device *netdev)
1633{
1634 disable_irq(netdev->irq);
1635 spider_net_interrupt(netdev->irq, netdev);
1636 enable_irq(netdev->irq);
1637}
1638#endif
1639
1640
1641
1642
1643
1644
1645
1646static void
1647spider_net_enable_interrupts(struct spider_net_card *card)
1648{
1649 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK,
1650 SPIDER_NET_INT0_MASK_VALUE);
1651 spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK,
1652 SPIDER_NET_INT1_MASK_VALUE);
1653 spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK,
1654 SPIDER_NET_INT2_MASK_VALUE);
1655}
1656
1657
1658
1659
1660
1661
1662
1663static void
1664spider_net_disable_interrupts(struct spider_net_card *card)
1665{
1666 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 0);
1667 spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 0);
1668 spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 0);
1669 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0);
1670}
1671
1672
1673
1674
1675
1676
1677
1678
1679static void
1680spider_net_init_card(struct spider_net_card *card)
1681{
1682 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
1683 SPIDER_NET_CKRCTRL_STOP_VALUE);
1684
1685 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
1686 SPIDER_NET_CKRCTRL_RUN_VALUE);
1687
1688
1689 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD,
1690 spider_net_read_reg(card, SPIDER_NET_GMACOPEMD) | 0x4);
1691
1692 spider_net_disable_interrupts(card);
1693}
1694
1695
1696
1697
1698
1699
1700
1701static void
1702spider_net_enable_card(struct spider_net_card *card)
1703{
1704 int i;
1705
1706
1707 u32 regs[][2] = {
1708 { SPIDER_NET_GRESUMINTNUM, 0 },
1709 { SPIDER_NET_GREINTNUM, 0 },
1710
1711
1712
1713 { SPIDER_NET_GFAFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1714 { SPIDER_NET_GFBFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1715 { SPIDER_NET_GFCFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1716 { SPIDER_NET_GFDFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1717
1718 { SPIDER_NET_GFFRMNUM, SPIDER_NET_FRAMENUM_VALUE },
1719
1720
1721 { SPIDER_NET_GFREECNNUM, 0 },
1722 { SPIDER_NET_GONETIMENUM, 0 },
1723 { SPIDER_NET_GTOUTFRMNUM, 0 },
1724
1725
1726 { SPIDER_NET_GRXMDSET, SPIDER_NET_RXMODE_VALUE },
1727
1728 { SPIDER_NET_GTXMDSET, SPIDER_NET_TXMODE_VALUE },
1729
1730 { SPIDER_NET_GIPSECINIT, SPIDER_NET_IPSECINIT_VALUE },
1731
1732 { SPIDER_NET_GFTRESTRT, SPIDER_NET_RESTART_VALUE },
1733
1734 { SPIDER_NET_GMRWOLCTRL, 0 },
1735 { SPIDER_NET_GTESTMD, 0x10000000 },
1736 { SPIDER_NET_GTTQMSK, 0x00400040 },
1737
1738 { SPIDER_NET_GMACINTEN, 0 },
1739
1740
1741 { SPIDER_NET_GMACAPAUSE, SPIDER_NET_MACAPAUSE_VALUE },
1742 { SPIDER_NET_GMACTXPAUSE, SPIDER_NET_TXPAUSE_VALUE },
1743
1744 { SPIDER_NET_GMACBSTLMT, SPIDER_NET_BURSTLMT_VALUE },
1745 { 0, 0}
1746 };
1747
1748 i = 0;
1749 while (regs[i][0]) {
1750 spider_net_write_reg(card, regs[i][0], regs[i][1]);
1751 i++;
1752 }
1753
1754
1755 for (i = 1; i <= 14; i++) {
1756 spider_net_write_reg(card,
1757 SPIDER_NET_GMRUAFILnR + i * 8,
1758 0x00080000);
1759 spider_net_write_reg(card,
1760 SPIDER_NET_GMRUAFILnR + i * 8 + 4,
1761 0x00000000);
1762 }
1763
1764 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 0x08080000);
1765
1766 spider_net_write_reg(card, SPIDER_NET_ECMODE, SPIDER_NET_ECMODE_VALUE);
1767
1768
1769
1770 spider_net_enable_rxchtails(card);
1771 spider_net_enable_rxdmac(card);
1772
1773 spider_net_write_reg(card, SPIDER_NET_GRXDMAEN, SPIDER_NET_WOL_VALUE);
1774
1775 spider_net_write_reg(card, SPIDER_NET_GMACLENLMT,
1776 SPIDER_NET_LENLMT_VALUE);
1777 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD,
1778 SPIDER_NET_OPMODE_VALUE);
1779
1780 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
1781 SPIDER_NET_GDTBSTA);
1782}
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792static int
1793spider_net_download_firmware(struct spider_net_card *card,
1794 const void *firmware_ptr)
1795{
1796 int sequencer, i;
1797 const u32 *fw_ptr = firmware_ptr;
1798
1799
1800 spider_net_write_reg(card, SPIDER_NET_GSINIT,
1801 SPIDER_NET_STOP_SEQ_VALUE);
1802
1803 for (sequencer = 0; sequencer < SPIDER_NET_FIRMWARE_SEQS;
1804 sequencer++) {
1805 spider_net_write_reg(card,
1806 SPIDER_NET_GSnPRGADR + sequencer * 8, 0);
1807 for (i = 0; i < SPIDER_NET_FIRMWARE_SEQWORDS; i++) {
1808 spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT +
1809 sequencer * 8, *fw_ptr);
1810 fw_ptr++;
1811 }
1812 }
1813
1814 if (spider_net_read_reg(card, SPIDER_NET_GSINIT))
1815 return -EIO;
1816
1817 spider_net_write_reg(card, SPIDER_NET_GSINIT,
1818 SPIDER_NET_RUN_SEQ_VALUE);
1819
1820 return 0;
1821}
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849static int
1850spider_net_init_firmware(struct spider_net_card *card)
1851{
1852 struct firmware *firmware = NULL;
1853 struct device_node *dn;
1854 const u8 *fw_prop = NULL;
1855 int err = -ENOENT;
1856 int fw_size;
1857
1858 if (request_firmware((const struct firmware **)&firmware,
1859 SPIDER_NET_FIRMWARE_NAME, &card->pdev->dev) == 0) {
1860 if ( (firmware->size != SPIDER_NET_FIRMWARE_LEN) &&
1861 netif_msg_probe(card) ) {
1862 dev_err(&card->netdev->dev,
1863 "Incorrect size of spidernet firmware in " \
1864 "filesystem. Looking in host firmware...\n");
1865 goto try_host_fw;
1866 }
1867 err = spider_net_download_firmware(card, firmware->data);
1868
1869 release_firmware(firmware);
1870 if (err)
1871 goto try_host_fw;
1872
1873 goto done;
1874 }
1875
1876try_host_fw:
1877 dn = pci_device_to_OF_node(card->pdev);
1878 if (!dn)
1879 goto out_err;
1880
1881 fw_prop = of_get_property(dn, "firmware", &fw_size);
1882 if (!fw_prop)
1883 goto out_err;
1884
1885 if ( (fw_size != SPIDER_NET_FIRMWARE_LEN) &&
1886 netif_msg_probe(card) ) {
1887 dev_err(&card->netdev->dev,
1888 "Incorrect size of spidernet firmware in host firmware\n");
1889 goto done;
1890 }
1891
1892 err = spider_net_download_firmware(card, fw_prop);
1893
1894done:
1895 return err;
1896out_err:
1897 if (netif_msg_probe(card))
1898 dev_err(&card->netdev->dev,
1899 "Couldn't find spidernet firmware in filesystem " \
1900 "or host firmware\n");
1901 return err;
1902}
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913int
1914spider_net_open(struct net_device *netdev)
1915{
1916 struct spider_net_card *card = netdev_priv(netdev);
1917 int result;
1918
1919 result = spider_net_init_firmware(card);
1920 if (result)
1921 goto init_firmware_failed;
1922
1923
1924 card->aneg_count = 0;
1925 card->medium = BCM54XX_COPPER;
1926 spider_net_setup_aneg(card);
1927 if (card->phy.def->phy_id)
1928 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER);
1929
1930 result = spider_net_init_chain(card, &card->tx_chain);
1931 if (result)
1932 goto alloc_tx_failed;
1933 card->low_watermark = NULL;
1934
1935 result = spider_net_init_chain(card, &card->rx_chain);
1936 if (result)
1937 goto alloc_rx_failed;
1938
1939
1940 result = spider_net_alloc_rx_skbs(card);
1941 if (result)
1942 goto alloc_skbs_failed;
1943
1944 spider_net_set_multi(netdev);
1945
1946
1947
1948 result = -EBUSY;
1949 if (request_irq(netdev->irq, spider_net_interrupt,
1950 IRQF_SHARED, netdev->name, netdev))
1951 goto register_int_failed;
1952
1953 spider_net_enable_card(card);
1954
1955 netif_start_queue(netdev);
1956 netif_carrier_on(netdev);
1957 napi_enable(&card->napi);
1958
1959 spider_net_enable_interrupts(card);
1960
1961 return 0;
1962
1963register_int_failed:
1964 spider_net_free_rx_chain_contents(card);
1965alloc_skbs_failed:
1966 spider_net_free_chain(card, &card->rx_chain);
1967alloc_rx_failed:
1968 spider_net_free_chain(card, &card->tx_chain);
1969alloc_tx_failed:
1970 del_timer_sync(&card->aneg_timer);
1971init_firmware_failed:
1972 return result;
1973}
1974
1975
1976
1977
1978
1979
1980static void spider_net_link_phy(unsigned long data)
1981{
1982 struct spider_net_card *card = (struct spider_net_card *)data;
1983 struct mii_phy *phy = &card->phy;
1984
1985
1986 if (card->aneg_count > SPIDER_NET_ANEG_TIMEOUT) {
1987
1988 pr_debug("%s: link is down trying to bring it up\n",
1989 card->netdev->name);
1990
1991 switch (card->medium) {
1992 case BCM54XX_COPPER:
1993
1994 if (phy->def->ops->enable_fiber)
1995 phy->def->ops->enable_fiber(phy, 1);
1996 card->medium = BCM54XX_FIBER;
1997 break;
1998
1999 case BCM54XX_FIBER:
2000
2001 if (phy->def->ops->enable_fiber)
2002 phy->def->ops->enable_fiber(phy, 0);
2003 card->medium = BCM54XX_UNKNOWN;
2004 break;
2005
2006 case BCM54XX_UNKNOWN:
2007
2008
2009 spider_net_setup_aneg(card);
2010 card->medium = BCM54XX_COPPER;
2011 break;
2012 }
2013
2014 card->aneg_count = 0;
2015 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER);
2016 return;
2017 }
2018
2019
2020 if (!(phy->def->ops->poll_link(phy))) {
2021 card->aneg_count++;
2022 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER);
2023 return;
2024 }
2025
2026
2027 phy->def->ops->read_link(phy);
2028
2029 spider_net_write_reg(card, SPIDER_NET_GMACST,
2030 spider_net_read_reg(card, SPIDER_NET_GMACST));
2031 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0x4);
2032
2033 if (phy->speed == 1000)
2034 spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0x00000001);
2035 else
2036 spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0);
2037
2038 card->aneg_count = 0;
2039
2040 pr_info("%s: link up, %i Mbps, %s-duplex %sautoneg.\n",
2041 card->netdev->name, phy->speed,
2042 phy->duplex == 1 ? "Full" : "Half",
2043 phy->autoneg == 1 ? "" : "no ");
2044}
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054static int
2055spider_net_setup_phy(struct spider_net_card *card)
2056{
2057 struct mii_phy *phy = &card->phy;
2058
2059 spider_net_write_reg(card, SPIDER_NET_GDTDMASEL,
2060 SPIDER_NET_DMASEL_VALUE);
2061 spider_net_write_reg(card, SPIDER_NET_GPCCTRL,
2062 SPIDER_NET_PHY_CTRL_VALUE);
2063
2064 phy->dev = card->netdev;
2065 phy->mdio_read = spider_net_read_phy;
2066 phy->mdio_write = spider_net_write_phy;
2067
2068 for (phy->mii_id = 1; phy->mii_id <= 31; phy->mii_id++) {
2069 unsigned short id;
2070 id = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR);
2071 if (id != 0x0000 && id != 0xffff) {
2072 if (!sungem_phy_probe(phy, phy->mii_id)) {
2073 pr_info("Found %s.\n", phy->def->name);
2074 break;
2075 }
2076 }
2077 }
2078
2079 return 0;
2080}
2081
2082
2083
2084
2085
2086
2087
2088static void
2089spider_net_workaround_rxramfull(struct spider_net_card *card)
2090{
2091 int i, sequencer = 0;
2092
2093
2094 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
2095 SPIDER_NET_CKRCTRL_RUN_VALUE);
2096
2097
2098 for (sequencer = 0; sequencer < SPIDER_NET_FIRMWARE_SEQS;
2099 sequencer++) {
2100 spider_net_write_reg(card, SPIDER_NET_GSnPRGADR +
2101 sequencer * 8, 0x0);
2102 for (i = 0; i < SPIDER_NET_FIRMWARE_SEQWORDS; i++) {
2103 spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT +
2104 sequencer * 8, 0x0);
2105 }
2106 }
2107
2108
2109 spider_net_write_reg(card, SPIDER_NET_GSINIT, 0x000000fe);
2110
2111
2112 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
2113 SPIDER_NET_CKRCTRL_STOP_VALUE);
2114}
2115
2116
2117
2118
2119
2120
2121
2122int
2123spider_net_stop(struct net_device *netdev)
2124{
2125 struct spider_net_card *card = netdev_priv(netdev);
2126
2127 napi_disable(&card->napi);
2128 netif_carrier_off(netdev);
2129 netif_stop_queue(netdev);
2130 del_timer_sync(&card->tx_timer);
2131 del_timer_sync(&card->aneg_timer);
2132
2133 spider_net_disable_interrupts(card);
2134
2135 free_irq(netdev->irq, netdev);
2136
2137 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
2138 SPIDER_NET_DMA_TX_FEND_VALUE);
2139
2140
2141 spider_net_disable_rxdmac(card);
2142
2143
2144 spider_net_release_tx_chain(card, 1);
2145 spider_net_free_rx_chain_contents(card);
2146
2147 spider_net_free_chain(card, &card->tx_chain);
2148 spider_net_free_chain(card, &card->rx_chain);
2149
2150 return 0;
2151}
2152
2153
2154
2155
2156
2157
2158
2159
2160static void
2161spider_net_tx_timeout_task(struct work_struct *work)
2162{
2163 struct spider_net_card *card =
2164 container_of(work, struct spider_net_card, tx_timeout_task);
2165 struct net_device *netdev = card->netdev;
2166
2167 if (!(netdev->flags & IFF_UP))
2168 goto out;
2169
2170 netif_device_detach(netdev);
2171 spider_net_stop(netdev);
2172
2173 spider_net_workaround_rxramfull(card);
2174 spider_net_init_card(card);
2175
2176 if (spider_net_setup_phy(card))
2177 goto out;
2178
2179 spider_net_open(netdev);
2180 spider_net_kick_tx_dma(card);
2181 netif_device_attach(netdev);
2182
2183out:
2184 atomic_dec(&card->tx_timeout_task_counter);
2185}
2186
2187
2188
2189
2190
2191
2192
2193static void
2194spider_net_tx_timeout(struct net_device *netdev)
2195{
2196 struct spider_net_card *card;
2197
2198 card = netdev_priv(netdev);
2199 atomic_inc(&card->tx_timeout_task_counter);
2200 if (netdev->flags & IFF_UP)
2201 schedule_work(&card->tx_timeout_task);
2202 else
2203 atomic_dec(&card->tx_timeout_task_counter);
2204 card->spider_stats.tx_timeouts++;
2205}
2206
2207static const struct net_device_ops spider_net_ops = {
2208 .ndo_open = spider_net_open,
2209 .ndo_stop = spider_net_stop,
2210 .ndo_start_xmit = spider_net_xmit,
2211 .ndo_set_rx_mode = spider_net_set_multi,
2212 .ndo_set_mac_address = spider_net_set_mac,
2213 .ndo_do_ioctl = spider_net_do_ioctl,
2214 .ndo_tx_timeout = spider_net_tx_timeout,
2215 .ndo_validate_addr = eth_validate_addr,
2216
2217#ifdef CONFIG_NET_POLL_CONTROLLER
2218
2219 .ndo_poll_controller = spider_net_poll_controller,
2220#endif
2221};
2222
2223
2224
2225
2226
2227
2228
2229static void
2230spider_net_setup_netdev_ops(struct net_device *netdev)
2231{
2232 netdev->netdev_ops = &spider_net_ops;
2233 netdev->watchdog_timeo = SPIDER_NET_WATCHDOG_TIMEOUT;
2234
2235 netdev->ethtool_ops = &spider_net_ethtool_ops;
2236}
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246static int
2247spider_net_setup_netdev(struct spider_net_card *card)
2248{
2249 int result;
2250 struct net_device *netdev = card->netdev;
2251 struct device_node *dn;
2252 struct sockaddr addr;
2253 const u8 *mac;
2254
2255 SET_NETDEV_DEV(netdev, &card->pdev->dev);
2256
2257 pci_set_drvdata(card->pdev, netdev);
2258
2259 init_timer(&card->tx_timer);
2260 card->tx_timer.function =
2261 (void (*)(unsigned long)) spider_net_cleanup_tx_ring;
2262 card->tx_timer.data = (unsigned long) card;
2263 netdev->irq = card->pdev->irq;
2264
2265 card->aneg_count = 0;
2266 init_timer(&card->aneg_timer);
2267 card->aneg_timer.function = spider_net_link_phy;
2268 card->aneg_timer.data = (unsigned long) card;
2269
2270 netif_napi_add(netdev, &card->napi,
2271 spider_net_poll, SPIDER_NET_NAPI_WEIGHT);
2272
2273 spider_net_setup_netdev_ops(netdev);
2274
2275 netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
2276 if (SPIDER_NET_RX_CSUM_DEFAULT)
2277 netdev->features |= NETIF_F_RXCSUM;
2278 netdev->features |= NETIF_F_IP_CSUM | NETIF_F_LLTX;
2279
2280
2281
2282
2283 netdev->min_mtu = SPIDER_NET_MIN_MTU;
2284 netdev->max_mtu = SPIDER_NET_MAX_MTU;
2285
2286 netdev->irq = card->pdev->irq;
2287 card->num_rx_ints = 0;
2288 card->ignore_rx_ramfull = 0;
2289
2290 dn = pci_device_to_OF_node(card->pdev);
2291 if (!dn)
2292 return -EIO;
2293
2294 mac = of_get_property(dn, "local-mac-address", NULL);
2295 if (!mac)
2296 return -EIO;
2297 memcpy(addr.sa_data, mac, ETH_ALEN);
2298
2299 result = spider_net_set_mac(netdev, &addr);
2300 if ((result) && (netif_msg_probe(card)))
2301 dev_err(&card->netdev->dev,
2302 "Failed to set MAC address: %i\n", result);
2303
2304 result = register_netdev(netdev);
2305 if (result) {
2306 if (netif_msg_probe(card))
2307 dev_err(&card->netdev->dev,
2308 "Couldn't register net_device: %i\n", result);
2309 return result;
2310 }
2311
2312 if (netif_msg_probe(card))
2313 pr_info("Initialized device %s.\n", netdev->name);
2314
2315 return 0;
2316}
2317
2318
2319
2320
2321
2322
2323
2324
2325static struct spider_net_card *
2326spider_net_alloc_card(void)
2327{
2328 struct net_device *netdev;
2329 struct spider_net_card *card;
2330 size_t alloc_size;
2331
2332 alloc_size = sizeof(struct spider_net_card) +
2333 (tx_descriptors + rx_descriptors) * sizeof(struct spider_net_descr);
2334 netdev = alloc_etherdev(alloc_size);
2335 if (!netdev)
2336 return NULL;
2337
2338 card = netdev_priv(netdev);
2339 card->netdev = netdev;
2340 card->msg_enable = SPIDER_NET_DEFAULT_MSG;
2341 INIT_WORK(&card->tx_timeout_task, spider_net_tx_timeout_task);
2342 init_waitqueue_head(&card->waitq);
2343 atomic_set(&card->tx_timeout_task_counter, 0);
2344
2345 card->rx_chain.num_desc = rx_descriptors;
2346 card->rx_chain.ring = card->darray;
2347 card->tx_chain.num_desc = tx_descriptors;
2348 card->tx_chain.ring = card->darray + rx_descriptors;
2349
2350 return card;
2351}
2352
2353
2354
2355
2356
2357
2358
2359static void
2360spider_net_undo_pci_setup(struct spider_net_card *card)
2361{
2362 iounmap(card->regs);
2363 pci_release_regions(card->pdev);
2364}
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378static struct spider_net_card *
2379spider_net_setup_pci_dev(struct pci_dev *pdev)
2380{
2381 struct spider_net_card *card;
2382 unsigned long mmio_start, mmio_len;
2383
2384 if (pci_enable_device(pdev)) {
2385 dev_err(&pdev->dev, "Couldn't enable PCI device\n");
2386 return NULL;
2387 }
2388
2389 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
2390 dev_err(&pdev->dev,
2391 "Couldn't find proper PCI device base address.\n");
2392 goto out_disable_dev;
2393 }
2394
2395 if (pci_request_regions(pdev, spider_net_driver_name)) {
2396 dev_err(&pdev->dev,
2397 "Couldn't obtain PCI resources, aborting.\n");
2398 goto out_disable_dev;
2399 }
2400
2401 pci_set_master(pdev);
2402
2403 card = spider_net_alloc_card();
2404 if (!card) {
2405 dev_err(&pdev->dev,
2406 "Couldn't allocate net_device structure, aborting.\n");
2407 goto out_release_regions;
2408 }
2409 card->pdev = pdev;
2410
2411
2412 mmio_start = pci_resource_start(pdev, 0);
2413 mmio_len = pci_resource_len(pdev, 0);
2414
2415 card->netdev->mem_start = mmio_start;
2416 card->netdev->mem_end = mmio_start + mmio_len;
2417 card->regs = ioremap(mmio_start, mmio_len);
2418
2419 if (!card->regs) {
2420 dev_err(&pdev->dev,
2421 "Couldn't obtain PCI resources, aborting.\n");
2422 goto out_release_regions;
2423 }
2424
2425 return card;
2426
2427out_release_regions:
2428 pci_release_regions(pdev);
2429out_disable_dev:
2430 pci_disable_device(pdev);
2431 return NULL;
2432}
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444static int
2445spider_net_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
2446{
2447 int err = -EIO;
2448 struct spider_net_card *card;
2449
2450 card = spider_net_setup_pci_dev(pdev);
2451 if (!card)
2452 goto out;
2453
2454 spider_net_workaround_rxramfull(card);
2455 spider_net_init_card(card);
2456
2457 err = spider_net_setup_phy(card);
2458 if (err)
2459 goto out_undo_pci;
2460
2461 err = spider_net_setup_netdev(card);
2462 if (err)
2463 goto out_undo_pci;
2464
2465 return 0;
2466
2467out_undo_pci:
2468 spider_net_undo_pci_setup(card);
2469 free_netdev(card->netdev);
2470out:
2471 return err;
2472}
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483static void
2484spider_net_remove(struct pci_dev *pdev)
2485{
2486 struct net_device *netdev;
2487 struct spider_net_card *card;
2488
2489 netdev = pci_get_drvdata(pdev);
2490 card = netdev_priv(netdev);
2491
2492 wait_event(card->waitq,
2493 atomic_read(&card->tx_timeout_task_counter) == 0);
2494
2495 unregister_netdev(netdev);
2496
2497
2498 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
2499 SPIDER_NET_CKRCTRL_STOP_VALUE);
2500 spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
2501 SPIDER_NET_CKRCTRL_RUN_VALUE);
2502
2503 spider_net_undo_pci_setup(card);
2504 free_netdev(netdev);
2505}
2506
2507static struct pci_driver spider_net_driver = {
2508 .name = spider_net_driver_name,
2509 .id_table = spider_net_pci_tbl,
2510 .probe = spider_net_probe,
2511 .remove = spider_net_remove
2512};
2513
2514
2515
2516
2517
2518
2519static int __init spider_net_init(void)
2520{
2521 printk(KERN_INFO "Spidernet version %s.\n", VERSION);
2522
2523 if (rx_descriptors < SPIDER_NET_RX_DESCRIPTORS_MIN) {
2524 rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MIN;
2525 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors);
2526 }
2527 if (rx_descriptors > SPIDER_NET_RX_DESCRIPTORS_MAX) {
2528 rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MAX;
2529 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors);
2530 }
2531 if (tx_descriptors < SPIDER_NET_TX_DESCRIPTORS_MIN) {
2532 tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MIN;
2533 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors);
2534 }
2535 if (tx_descriptors > SPIDER_NET_TX_DESCRIPTORS_MAX) {
2536 tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MAX;
2537 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors);
2538 }
2539
2540 return pci_register_driver(&spider_net_driver);
2541}
2542
2543
2544
2545
2546
2547
2548static void __exit spider_net_cleanup(void)
2549{
2550 pci_unregister_driver(&spider_net_driver);
2551}
2552
2553module_init(spider_net_init);
2554module_exit(spider_net_cleanup);
2555