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