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