2 * Network device driver for Cell Processor-Based Blade and Celleb platform
4 * (C) Copyright IBM Corp. 2005
5 * (C) Copyright 2006 TOSHIBA CORPORATION
7 * Authors : Utz Bacher <utz.bacher@de.ibm.com>
8 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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>
33 #include <linux/init.h>
34 #include <linux/ioport.h>
36 #include <linux/kernel.h>
37 #include <linux/mii.h>
38 #include <linux/module.h>
39 #include <linux/netdevice.h>
40 #include <linux/device.h>
41 #include <linux/pci.h>
42 #include <linux/skbuff.h>
43 #include <linux/slab.h>
44 #include <linux/tcp.h>
45 #include <linux/types.h>
46 #include <linux/vmalloc.h>
47 #include <linux/wait.h>
48 #include <linux/workqueue.h>
49 #include <asm/bitops.h>
50 #include <asm/pci-bridge.h>
51 #include <net/checksum.h>
53 #include "spider_net.h"
55 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com> and Jens Osterkamp " \
56 "<Jens.Osterkamp@de.ibm.com>");
57 MODULE_DESCRIPTION("Spider Southbridge Gigabit Ethernet driver");
58 MODULE_LICENSE("GPL");
59 MODULE_VERSION(VERSION
);
61 static int rx_descriptors
= SPIDER_NET_RX_DESCRIPTORS_DEFAULT
;
62 static int tx_descriptors
= SPIDER_NET_TX_DESCRIPTORS_DEFAULT
;
64 module_param(rx_descriptors
, int, 0444);
65 module_param(tx_descriptors
, int, 0444);
67 MODULE_PARM_DESC(rx_descriptors
, "number of descriptors used " \
69 MODULE_PARM_DESC(tx_descriptors
, "number of descriptors used " \
72 char spider_net_driver_name
[] = "spidernet";
74 static struct pci_device_id spider_net_pci_tbl
[] = {
75 { PCI_VENDOR_ID_TOSHIBA_2
, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET
,
76 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
80 MODULE_DEVICE_TABLE(pci
, spider_net_pci_tbl
);
83 * spider_net_read_reg - reads an SMMIO register of a card
84 * @card: device structure
85 * @reg: register to read from
87 * returns the content of the specified SMMIO register.
90 spider_net_read_reg(struct spider_net_card
*card
, u32 reg
)
92 /* We use the powerpc specific variants instead of readl_be() because
93 * we know spidernet is not a real PCI device and we can thus avoid the
94 * performance hit caused by the PCI workarounds.
96 return in_be32(card
->regs
+ reg
);
100 * spider_net_write_reg - writes to an SMMIO register of a card
101 * @card: device structure
102 * @reg: register to write to
103 * @value: value to write into the specified SMMIO register
106 spider_net_write_reg(struct spider_net_card
*card
, u32 reg
, u32 value
)
108 /* We use the powerpc specific variants instead of writel_be() because
109 * we know spidernet is not a real PCI device and we can thus avoid the
110 * performance hit caused by the PCI workarounds.
112 out_be32(card
->regs
+ reg
, value
);
115 /** spider_net_write_phy - write to phy register
116 * @netdev: adapter to be written to
119 * @val: value to be written to phy register
121 * spider_net_write_phy_register writes to an arbitrary PHY
122 * register via the spider GPCWOPCMD register. We assume the queue does
123 * not run full (not more than 15 commands outstanding).
126 spider_net_write_phy(struct net_device
*netdev
, int mii_id
,
129 struct spider_net_card
*card
= netdev_priv(netdev
);
132 writevalue
= ((u32
)mii_id
<< 21) |
133 ((u32
)reg
<< 16) | ((u32
)val
);
135 spider_net_write_reg(card
, SPIDER_NET_GPCWOPCMD
, writevalue
);
138 /** spider_net_read_phy - read from phy register
139 * @netdev: network device to be read from
143 * Returns value read from PHY register
145 * spider_net_write_phy reads from an arbitrary PHY
146 * register via the spider GPCROPCMD register
149 spider_net_read_phy(struct net_device
*netdev
, int mii_id
, int reg
)
151 struct spider_net_card
*card
= netdev_priv(netdev
);
154 readvalue
= ((u32
)mii_id
<< 21) | ((u32
)reg
<< 16);
155 spider_net_write_reg(card
, SPIDER_NET_GPCROPCMD
, readvalue
);
157 /* we don't use semaphores to wait for an SPIDER_NET_GPROPCMPINT
158 * interrupt, as we poll for the completion of the read operation
159 * in spider_net_read_phy. Should take about 50 us */
161 readvalue
= spider_net_read_reg(card
, SPIDER_NET_GPCROPCMD
);
162 } while (readvalue
& SPIDER_NET_GPREXEC
);
164 readvalue
&= SPIDER_NET_GPRDAT_MASK
;
170 * spider_net_setup_aneg - initial auto-negotiation setup
171 * @card: device structure
174 spider_net_setup_aneg(struct spider_net_card
*card
)
176 struct mii_phy
*phy
= &card
->phy
;
180 bmsr
= spider_net_read_phy(card
->netdev
, phy
->mii_id
, MII_BMSR
);
181 estat
= spider_net_read_phy(card
->netdev
, phy
->mii_id
, MII_ESTATUS
);
183 if (bmsr
& BMSR_10HALF
)
184 advertise
|= ADVERTISED_10baseT_Half
;
185 if (bmsr
& BMSR_10FULL
)
186 advertise
|= ADVERTISED_10baseT_Full
;
187 if (bmsr
& BMSR_100HALF
)
188 advertise
|= ADVERTISED_100baseT_Half
;
189 if (bmsr
& BMSR_100FULL
)
190 advertise
|= ADVERTISED_100baseT_Full
;
192 if ((bmsr
& BMSR_ESTATEN
) && (estat
& ESTATUS_1000_TFULL
))
193 advertise
|= SUPPORTED_1000baseT_Full
;
194 if ((bmsr
& BMSR_ESTATEN
) && (estat
& ESTATUS_1000_THALF
))
195 advertise
|= SUPPORTED_1000baseT_Half
;
197 mii_phy_probe(phy
, phy
->mii_id
);
198 phy
->def
->ops
->setup_aneg(phy
, advertise
);
203 * spider_net_rx_irq_off - switch off rx irq on this spider card
204 * @card: device structure
206 * switches off rx irq by masking them out in the GHIINTnMSK register
209 spider_net_rx_irq_off(struct spider_net_card
*card
)
213 regvalue
= SPIDER_NET_INT0_MASK_VALUE
& (~SPIDER_NET_RXINT
);
214 spider_net_write_reg(card
, SPIDER_NET_GHIINT0MSK
, regvalue
);
218 * spider_net_rx_irq_on - switch on rx irq on this spider card
219 * @card: device structure
221 * switches on rx irq by enabling them in the GHIINTnMSK register
224 spider_net_rx_irq_on(struct spider_net_card
*card
)
228 regvalue
= SPIDER_NET_INT0_MASK_VALUE
| SPIDER_NET_RXINT
;
229 spider_net_write_reg(card
, SPIDER_NET_GHIINT0MSK
, regvalue
);
233 * spider_net_set_promisc - sets the unicast address or the promiscuous mode
234 * @card: card structure
236 * spider_net_set_promisc sets the unicast destination address filter and
237 * thus either allows for non-promisc mode or promisc mode
240 spider_net_set_promisc(struct spider_net_card
*card
)
243 struct net_device
*netdev
= card
->netdev
;
245 if (netdev
->flags
& IFF_PROMISC
) {
246 /* clear destination entry 0 */
247 spider_net_write_reg(card
, SPIDER_NET_GMRUAFILnR
, 0);
248 spider_net_write_reg(card
, SPIDER_NET_GMRUAFILnR
+ 0x04, 0);
249 spider_net_write_reg(card
, SPIDER_NET_GMRUA0FIL15R
,
250 SPIDER_NET_PROMISC_VALUE
);
252 macu
= netdev
->dev_addr
[0];
254 macu
|= netdev
->dev_addr
[1];
255 memcpy(&macl
, &netdev
->dev_addr
[2], sizeof(macl
));
257 macu
|= SPIDER_NET_UA_DESCR_VALUE
;
258 spider_net_write_reg(card
, SPIDER_NET_GMRUAFILnR
, macu
);
259 spider_net_write_reg(card
, SPIDER_NET_GMRUAFILnR
+ 0x04, macl
);
260 spider_net_write_reg(card
, SPIDER_NET_GMRUA0FIL15R
,
261 SPIDER_NET_NONPROMISC_VALUE
);
266 * spider_net_get_mac_address - read mac address from spider card
267 * @card: device structure
269 * reads MAC address from GMACUNIMACU and GMACUNIMACL registers
272 spider_net_get_mac_address(struct net_device
*netdev
)
274 struct spider_net_card
*card
= netdev_priv(netdev
);
277 macl
= spider_net_read_reg(card
, SPIDER_NET_GMACUNIMACL
);
278 macu
= spider_net_read_reg(card
, SPIDER_NET_GMACUNIMACU
);
280 netdev
->dev_addr
[0] = (macu
>> 24) & 0xff;
281 netdev
->dev_addr
[1] = (macu
>> 16) & 0xff;
282 netdev
->dev_addr
[2] = (macu
>> 8) & 0xff;
283 netdev
->dev_addr
[3] = macu
& 0xff;
284 netdev
->dev_addr
[4] = (macl
>> 8) & 0xff;
285 netdev
->dev_addr
[5] = macl
& 0xff;
287 if (!is_valid_ether_addr(&netdev
->dev_addr
[0]))
294 * spider_net_get_descr_status -- returns the status of a descriptor
295 * @descr: descriptor to look at
297 * returns the status as in the dmac_cmd_status field of the descriptor
300 spider_net_get_descr_status(struct spider_net_hw_descr
*hwdescr
)
302 return hwdescr
->dmac_cmd_status
& SPIDER_NET_DESCR_IND_PROC_MASK
;
306 * spider_net_free_chain - free descriptor chain
307 * @card: card structure
308 * @chain: address of chain
312 spider_net_free_chain(struct spider_net_card
*card
,
313 struct spider_net_descr_chain
*chain
)
315 struct spider_net_descr
*descr
;
320 descr
->hwdescr
->next_descr_addr
= 0;
322 } while (descr
!= chain
->ring
);
324 dma_free_coherent(&card
->pdev
->dev
, chain
->num_desc
,
325 chain
->hwring
, chain
->dma_addr
);
329 * spider_net_init_chain - alloc and link descriptor chain
330 * @card: card structure
331 * @chain: address of chain
333 * We manage a circular list that mirrors the hardware structure,
334 * except that the hardware uses bus addresses.
336 * Returns 0 on success, <0 on failure
339 spider_net_init_chain(struct spider_net_card
*card
,
340 struct spider_net_descr_chain
*chain
)
343 struct spider_net_descr
*descr
;
344 struct spider_net_hw_descr
*hwdescr
;
348 alloc_size
= chain
->num_desc
* sizeof(struct spider_net_hw_descr
);
350 chain
->hwring
= dma_alloc_coherent(&card
->pdev
->dev
, alloc_size
,
351 &chain
->dma_addr
, GFP_KERNEL
);
356 memset(chain
->ring
, 0, chain
->num_desc
* sizeof(struct spider_net_descr
));
358 /* Set up the hardware pointers in each descriptor */
360 hwdescr
= chain
->hwring
;
361 buf
= chain
->dma_addr
;
362 for (i
=0; i
< chain
->num_desc
; i
++, descr
++, hwdescr
++) {
363 hwdescr
->dmac_cmd_status
= SPIDER_NET_DESCR_NOT_IN_USE
;
364 hwdescr
->next_descr_addr
= 0;
366 descr
->hwdescr
= hwdescr
;
367 descr
->bus_addr
= buf
;
368 descr
->next
= descr
+ 1;
369 descr
->prev
= descr
- 1;
371 buf
+= sizeof(struct spider_net_hw_descr
);
373 /* do actual circular list */
374 (descr
-1)->next
= chain
->ring
;
375 chain
->ring
->prev
= descr
-1;
377 spin_lock_init(&chain
->lock
);
378 chain
->head
= chain
->ring
;
379 chain
->tail
= chain
->ring
;
384 * spider_net_free_rx_chain_contents - frees descr contents in rx chain
385 * @card: card structure
387 * returns 0 on success, <0 on failure
390 spider_net_free_rx_chain_contents(struct spider_net_card
*card
)
392 struct spider_net_descr
*descr
;
394 descr
= card
->rx_chain
.head
;
397 pci_unmap_single(card
->pdev
, descr
->hwdescr
->buf_addr
,
398 SPIDER_NET_MAX_FRAME
,
399 PCI_DMA_BIDIRECTIONAL
);
400 dev_kfree_skb(descr
->skb
);
404 } while (descr
!= card
->rx_chain
.head
);
408 * spider_net_prepare_rx_descr - Reinitialize RX descriptor
409 * @card: card structure
410 * @descr: descriptor to re-init
412 * Return 0 on succes, <0 on failure.
414 * Allocates a new rx skb, iommu-maps it and attaches it to the
415 * descriptor. Mark the descriptor as activated, ready-to-use.
418 spider_net_prepare_rx_descr(struct spider_net_card
*card
,
419 struct spider_net_descr
*descr
)
421 struct spider_net_hw_descr
*hwdescr
= descr
->hwdescr
;
426 /* we need to round up the buffer size to a multiple of 128 */
427 bufsize
= (SPIDER_NET_MAX_FRAME
+ SPIDER_NET_RXBUF_ALIGN
- 1) &
428 (~(SPIDER_NET_RXBUF_ALIGN
- 1));
430 /* and we need to have it 128 byte aligned, therefore we allocate a
432 /* allocate an skb */
433 descr
->skb
= netdev_alloc_skb(card
->netdev
,
434 bufsize
+ SPIDER_NET_RXBUF_ALIGN
- 1);
436 if (netif_msg_rx_err(card
) && net_ratelimit())
437 dev_err(&card
->netdev
->dev
,
438 "Not enough memory to allocate rx buffer\n");
439 card
->spider_stats
.alloc_rx_skb_error
++;
442 hwdescr
->buf_size
= bufsize
;
443 hwdescr
->result_size
= 0;
444 hwdescr
->valid_size
= 0;
445 hwdescr
->data_status
= 0;
446 hwdescr
->data_error
= 0;
448 offset
= ((unsigned long)descr
->skb
->data
) &
449 (SPIDER_NET_RXBUF_ALIGN
- 1);
451 skb_reserve(descr
->skb
, SPIDER_NET_RXBUF_ALIGN
- offset
);
452 /* iommu-map the skb */
453 buf
= pci_map_single(card
->pdev
, descr
->skb
->data
,
454 SPIDER_NET_MAX_FRAME
, PCI_DMA_FROMDEVICE
);
455 if (pci_dma_mapping_error(buf
)) {
456 dev_kfree_skb_any(descr
->skb
);
458 if (netif_msg_rx_err(card
) && net_ratelimit())
459 dev_err(&card
->netdev
->dev
, "Could not iommu-map rx buffer\n");
460 card
->spider_stats
.rx_iommu_map_error
++;
461 hwdescr
->dmac_cmd_status
= SPIDER_NET_DESCR_NOT_IN_USE
;
463 hwdescr
->buf_addr
= buf
;
465 hwdescr
->dmac_cmd_status
= SPIDER_NET_DESCR_CARDOWNED
|
466 SPIDER_NET_DMAC_NOINTR_COMPLETE
;
473 * spider_net_enable_rxchtails - sets RX dmac chain tail addresses
474 * @card: card structure
476 * spider_net_enable_rxchtails sets the RX DMAC chain tail adresses in the
477 * chip by writing to the appropriate register. DMA is enabled in
478 * spider_net_enable_rxdmac.
481 spider_net_enable_rxchtails(struct spider_net_card
*card
)
483 /* assume chain is aligned correctly */
484 spider_net_write_reg(card
, SPIDER_NET_GDADCHA
,
485 card
->rx_chain
.tail
->bus_addr
);
489 * spider_net_enable_rxdmac - enables a receive DMA controller
490 * @card: card structure
492 * spider_net_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
493 * in the GDADMACCNTR register
496 spider_net_enable_rxdmac(struct spider_net_card
*card
)
499 spider_net_write_reg(card
, SPIDER_NET_GDADMACCNTR
,
500 SPIDER_NET_DMA_RX_VALUE
);
504 * spider_net_disable_rxdmac - disables the receive DMA controller
505 * @card: card structure
507 * spider_net_disable_rxdmac terminates processing on the DMA controller
508 * by turing off the DMA controller, with the force-end flag set.
511 spider_net_disable_rxdmac(struct spider_net_card
*card
)
513 spider_net_write_reg(card
, SPIDER_NET_GDADMACCNTR
,
514 SPIDER_NET_DMA_RX_FEND_VALUE
);
518 * spider_net_refill_rx_chain - refills descriptors/skbs in the rx chains
519 * @card: card structure
521 * refills descriptors in the rx chain: allocates skbs and iommu-maps them.
524 spider_net_refill_rx_chain(struct spider_net_card
*card
)
526 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
529 /* one context doing the refill (and a second context seeing that
530 * and omitting it) is ok. If called by NAPI, we'll be called again
531 * as spider_net_decode_one_descr is called several times. If some
532 * interrupt calls us, the NAPI is about to clean up anyway. */
533 if (!spin_trylock_irqsave(&chain
->lock
, flags
))
536 while (spider_net_get_descr_status(chain
->head
->hwdescr
) ==
537 SPIDER_NET_DESCR_NOT_IN_USE
) {
538 if (spider_net_prepare_rx_descr(card
, chain
->head
))
540 chain
->head
= chain
->head
->next
;
543 spin_unlock_irqrestore(&chain
->lock
, flags
);
547 * spider_net_alloc_rx_skbs - Allocates rx skbs in rx descriptor chains
548 * @card: card structure
550 * Returns 0 on success, <0 on failure.
553 spider_net_alloc_rx_skbs(struct spider_net_card
*card
)
555 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
556 struct spider_net_descr
*start
= chain
->tail
;
557 struct spider_net_descr
*descr
= start
;
559 /* Link up the hardware chain pointers */
561 descr
->prev
->hwdescr
->next_descr_addr
= descr
->bus_addr
;
563 } while (descr
!= start
);
565 /* Put at least one buffer into the chain. if this fails,
566 * we've got a problem. If not, spider_net_refill_rx_chain
567 * will do the rest at the end of this function. */
568 if (spider_net_prepare_rx_descr(card
, chain
->head
))
571 chain
->head
= chain
->head
->next
;
573 /* This will allocate the rest of the rx buffers;
574 * if not, it's business as usual later on. */
575 spider_net_refill_rx_chain(card
);
576 spider_net_enable_rxdmac(card
);
580 spider_net_free_rx_chain_contents(card
);
585 * spider_net_get_multicast_hash - generates hash for multicast filter table
586 * @addr: multicast address
588 * returns the hash value.
590 * spider_net_get_multicast_hash calculates a hash value for a given multicast
591 * address, that is used to set the multicast filter tables
594 spider_net_get_multicast_hash(struct net_device
*netdev
, __u8
*addr
)
598 char addr_for_crc
[ETH_ALEN
] = { 0, };
601 for (i
= 0; i
< ETH_ALEN
* 8; i
++) {
602 bit
= (addr
[i
/ 8] >> (i
% 8)) & 1;
603 addr_for_crc
[ETH_ALEN
- 1 - i
/ 8] += bit
<< (7 - (i
% 8));
606 crc
= crc32_be(~0, addr_for_crc
, netdev
->addr_len
);
617 * spider_net_set_multi - sets multicast addresses and promisc flags
618 * @netdev: interface device structure
620 * spider_net_set_multi configures multicast addresses as needed for the
621 * netdev interface. It also sets up multicast, allmulti and promisc
622 * flags appropriately
625 spider_net_set_multi(struct net_device
*netdev
)
627 struct dev_mc_list
*mc
;
631 struct spider_net_card
*card
= netdev_priv(netdev
);
632 unsigned long bitmask
[SPIDER_NET_MULTICAST_HASHES
/ BITS_PER_LONG
] =
635 spider_net_set_promisc(card
);
637 if (netdev
->flags
& IFF_ALLMULTI
) {
638 for (i
= 0; i
< SPIDER_NET_MULTICAST_HASHES
; i
++) {
644 /* well, we know, what the broadcast hash value is: it's xfd
645 hash = spider_net_get_multicast_hash(netdev, netdev->broadcast); */
646 set_bit(0xfd, bitmask
);
648 for (mc
= netdev
->mc_list
; mc
; mc
= mc
->next
) {
649 hash
= spider_net_get_multicast_hash(netdev
, mc
->dmi_addr
);
650 set_bit(hash
, bitmask
);
654 for (i
= 0; i
< SPIDER_NET_MULTICAST_HASHES
/ 4; i
++) {
656 if (test_bit(i
* 4, bitmask
))
659 if (test_bit(i
* 4 + 1, bitmask
))
662 if (test_bit(i
* 4 + 2, bitmask
))
665 if (test_bit(i
* 4 + 3, bitmask
))
668 spider_net_write_reg(card
, SPIDER_NET_GMRMHFILnR
+ i
* 4, reg
);
673 * spider_net_prepare_tx_descr - fill tx descriptor with skb data
674 * @card: card structure
675 * @descr: descriptor structure to fill out
676 * @skb: packet to use
678 * returns 0 on success, <0 on failure.
680 * fills out the descriptor structure with skb data and len. Copies data,
681 * if needed (32bit DMA!)
684 spider_net_prepare_tx_descr(struct spider_net_card
*card
,
687 struct spider_net_descr_chain
*chain
= &card
->tx_chain
;
688 struct spider_net_descr
*descr
;
689 struct spider_net_hw_descr
*hwdescr
;
693 buf
= pci_map_single(card
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
694 if (pci_dma_mapping_error(buf
)) {
695 if (netif_msg_tx_err(card
) && net_ratelimit())
696 dev_err(&card
->netdev
->dev
, "could not iommu-map packet (%p, %i). "
697 "Dropping packet\n", skb
->data
, skb
->len
);
698 card
->spider_stats
.tx_iommu_map_error
++;
702 spin_lock_irqsave(&chain
->lock
, flags
);
703 descr
= card
->tx_chain
.head
;
704 if (descr
->next
== chain
->tail
->prev
) {
705 spin_unlock_irqrestore(&chain
->lock
, flags
);
706 pci_unmap_single(card
->pdev
, buf
, skb
->len
, PCI_DMA_TODEVICE
);
709 hwdescr
= descr
->hwdescr
;
710 chain
->head
= descr
->next
;
713 hwdescr
->buf_addr
= buf
;
714 hwdescr
->buf_size
= skb
->len
;
715 hwdescr
->next_descr_addr
= 0;
716 hwdescr
->data_status
= 0;
718 hwdescr
->dmac_cmd_status
=
719 SPIDER_NET_DESCR_CARDOWNED
| SPIDER_NET_DMAC_TXFRMTL
;
720 spin_unlock_irqrestore(&chain
->lock
, flags
);
722 if (skb
->ip_summed
== CHECKSUM_PARTIAL
)
723 switch (ip_hdr(skb
)->protocol
) {
725 hwdescr
->dmac_cmd_status
|= SPIDER_NET_DMAC_TCP
;
728 hwdescr
->dmac_cmd_status
|= SPIDER_NET_DMAC_UDP
;
732 /* Chain the bus address, so that the DMA engine finds this descr. */
734 descr
->prev
->hwdescr
->next_descr_addr
= descr
->bus_addr
;
736 card
->netdev
->trans_start
= jiffies
; /* set netdev watchdog timer */
741 spider_net_set_low_watermark(struct spider_net_card
*card
)
743 struct spider_net_descr
*descr
= card
->tx_chain
.tail
;
744 struct spider_net_hw_descr
*hwdescr
;
750 /* Measure the length of the queue. Measurement does not
751 * need to be precise -- does not need a lock. */
752 while (descr
!= card
->tx_chain
.head
) {
753 status
= descr
->hwdescr
->dmac_cmd_status
& SPIDER_NET_DESCR_NOT_IN_USE
;
754 if (status
== SPIDER_NET_DESCR_NOT_IN_USE
)
760 /* If TX queue is short, don't even bother with interrupts */
761 if (cnt
< card
->tx_chain
.num_desc
/4)
764 /* Set low-watermark 3/4th's of the way into the queue. */
765 descr
= card
->tx_chain
.tail
;
770 /* Set the new watermark, clear the old watermark */
771 spin_lock_irqsave(&card
->tx_chain
.lock
, flags
);
772 descr
->hwdescr
->dmac_cmd_status
|= SPIDER_NET_DESCR_TXDESFLG
;
773 if (card
->low_watermark
&& card
->low_watermark
!= descr
) {
774 hwdescr
= card
->low_watermark
->hwdescr
;
775 hwdescr
->dmac_cmd_status
=
776 hwdescr
->dmac_cmd_status
& ~SPIDER_NET_DESCR_TXDESFLG
;
778 card
->low_watermark
= descr
;
779 spin_unlock_irqrestore(&card
->tx_chain
.lock
, flags
);
784 * spider_net_release_tx_chain - processes sent tx descriptors
785 * @card: adapter structure
786 * @brutal: if set, don't care about whether descriptor seems to be in use
788 * returns 0 if the tx ring is empty, otherwise 1.
790 * spider_net_release_tx_chain releases the tx descriptors that spider has
791 * finished with (if non-brutal) or simply release tx descriptors (if brutal).
792 * If some other context is calling this function, we return 1 so that we're
793 * scheduled again (if we were scheduled) and will not loose initiative.
796 spider_net_release_tx_chain(struct spider_net_card
*card
, int brutal
)
798 struct spider_net_descr_chain
*chain
= &card
->tx_chain
;
799 struct spider_net_descr
*descr
;
800 struct spider_net_hw_descr
*hwdescr
;
807 spin_lock_irqsave(&chain
->lock
, flags
);
808 if (chain
->tail
== chain
->head
) {
809 spin_unlock_irqrestore(&chain
->lock
, flags
);
813 hwdescr
= descr
->hwdescr
;
815 status
= spider_net_get_descr_status(hwdescr
);
817 case SPIDER_NET_DESCR_COMPLETE
:
818 card
->netdev_stats
.tx_packets
++;
819 card
->netdev_stats
.tx_bytes
+= descr
->skb
->len
;
822 case SPIDER_NET_DESCR_CARDOWNED
:
824 spin_unlock_irqrestore(&chain
->lock
, flags
);
828 /* fallthrough, if we release the descriptors
829 * brutally (then we don't care about
830 * SPIDER_NET_DESCR_CARDOWNED) */
832 case SPIDER_NET_DESCR_RESPONSE_ERROR
:
833 case SPIDER_NET_DESCR_PROTECTION_ERROR
:
834 case SPIDER_NET_DESCR_FORCE_END
:
835 if (netif_msg_tx_err(card
))
836 dev_err(&card
->netdev
->dev
, "forcing end of tx descriptor "
837 "with status x%02x\n", status
);
838 card
->netdev_stats
.tx_errors
++;
842 card
->netdev_stats
.tx_dropped
++;
844 spin_unlock_irqrestore(&chain
->lock
, flags
);
849 chain
->tail
= descr
->next
;
850 hwdescr
->dmac_cmd_status
|= SPIDER_NET_DESCR_NOT_IN_USE
;
853 buf_addr
= hwdescr
->buf_addr
;
854 spin_unlock_irqrestore(&chain
->lock
, flags
);
858 pci_unmap_single(card
->pdev
, buf_addr
, skb
->len
,
867 * spider_net_kick_tx_dma - enables TX DMA processing
868 * @card: card structure
869 * @descr: descriptor address to enable TX processing at
871 * This routine will start the transmit DMA running if
872 * it is not already running. This routine ned only be
873 * called when queueing a new packet to an empty tx queue.
874 * Writes the current tx chain head as start address
875 * of the tx descriptor chain and enables the transmission
879 spider_net_kick_tx_dma(struct spider_net_card
*card
)
881 struct spider_net_descr
*descr
;
883 if (spider_net_read_reg(card
, SPIDER_NET_GDTDMACCNTR
) &
884 SPIDER_NET_TX_DMA_EN
)
887 descr
= card
->tx_chain
.tail
;
889 if (spider_net_get_descr_status(descr
->hwdescr
) ==
890 SPIDER_NET_DESCR_CARDOWNED
) {
891 spider_net_write_reg(card
, SPIDER_NET_GDTDCHA
,
893 spider_net_write_reg(card
, SPIDER_NET_GDTDMACCNTR
,
894 SPIDER_NET_DMA_TX_VALUE
);
897 if (descr
== card
->tx_chain
.head
)
903 mod_timer(&card
->tx_timer
, jiffies
+ SPIDER_NET_TX_TIMER
);
907 * spider_net_xmit - transmits a frame over the device
908 * @skb: packet to send out
909 * @netdev: interface device structure
911 * returns 0 on success, !0 on failure
914 spider_net_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
917 struct spider_net_card
*card
= netdev_priv(netdev
);
919 spider_net_release_tx_chain(card
, 0);
921 if (spider_net_prepare_tx_descr(card
, skb
) != 0) {
922 card
->netdev_stats
.tx_dropped
++;
923 netif_stop_queue(netdev
);
924 return NETDEV_TX_BUSY
;
927 cnt
= spider_net_set_low_watermark(card
);
929 spider_net_kick_tx_dma(card
);
934 * spider_net_cleanup_tx_ring - cleans up the TX ring
935 * @card: card structure
937 * spider_net_cleanup_tx_ring is called by either the tx_timer
938 * or from the NAPI polling routine.
939 * This routine releases resources associted with transmitted
940 * packets, including updating the queue tail pointer.
943 spider_net_cleanup_tx_ring(struct spider_net_card
*card
)
945 if ((spider_net_release_tx_chain(card
, 0) != 0) &&
946 (card
->netdev
->flags
& IFF_UP
)) {
947 spider_net_kick_tx_dma(card
);
948 netif_wake_queue(card
->netdev
);
953 * spider_net_do_ioctl - called for device ioctls
954 * @netdev: interface device structure
955 * @ifr: request parameter structure for ioctl
956 * @cmd: command code for ioctl
958 * returns 0 on success, <0 on failure. Currently, we have no special ioctls.
959 * -EOPNOTSUPP is returned, if an unknown ioctl was requested
962 spider_net_do_ioctl(struct net_device
*netdev
, struct ifreq
*ifr
, int cmd
)
971 * spider_net_pass_skb_up - takes an skb from a descriptor and passes it on
972 * @descr: descriptor to process
973 * @card: card structure
975 * Fills out skb structure and passes the data to the stack.
976 * The descriptor state is not changed.
979 spider_net_pass_skb_up(struct spider_net_descr
*descr
,
980 struct spider_net_card
*card
)
982 struct spider_net_hw_descr
*hwdescr
= descr
->hwdescr
;
984 struct net_device
*netdev
;
985 u32 data_status
, data_error
;
987 data_status
= hwdescr
->data_status
;
988 data_error
= hwdescr
->data_error
;
989 netdev
= card
->netdev
;
992 skb_put(skb
, hwdescr
->valid_size
);
994 /* the card seems to add 2 bytes of junk in front
995 * of the ethernet frame */
996 #define SPIDER_MISALIGN 2
997 skb_pull(skb
, SPIDER_MISALIGN
);
998 skb
->protocol
= eth_type_trans(skb
, netdev
);
1000 /* checksum offload */
1001 if (card
->options
.rx_csum
) {
1002 if ( ( (data_status
& SPIDER_NET_DATA_STATUS_CKSUM_MASK
) ==
1003 SPIDER_NET_DATA_STATUS_CKSUM_MASK
) &&
1004 !(data_error
& SPIDER_NET_DATA_ERR_CKSUM_MASK
))
1005 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1007 skb
->ip_summed
= CHECKSUM_NONE
;
1009 skb
->ip_summed
= CHECKSUM_NONE
;
1011 if (data_status
& SPIDER_NET_VLAN_PACKET
) {
1012 /* further enhancements: HW-accel VLAN
1013 * vlan_hwaccel_receive_skb
1017 /* update netdevice statistics */
1018 card
->netdev_stats
.rx_packets
++;
1019 card
->netdev_stats
.rx_bytes
+= skb
->len
;
1021 /* pass skb up to stack */
1022 netif_receive_skb(skb
);
1025 static void show_rx_chain(struct spider_net_card
*card
)
1027 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
1028 struct spider_net_descr
*start
= chain
->tail
;
1029 struct spider_net_descr
*descr
= start
;
1030 struct spider_net_hw_descr
*hwd
= start
->hwdescr
;
1031 struct device
*dev
= &card
->netdev
->dev
;
1032 u32 curr_desc
, next_desc
;
1037 int off
= start
- chain
->ring
;
1038 int cstat
= hwd
->dmac_cmd_status
;
1040 dev_info(dev
, "Total number of descrs=%d\n",
1042 dev_info(dev
, "Chain tail located at descr=%d, status=0x%x\n",
1045 curr_desc
= spider_net_read_reg(card
, SPIDER_NET_GDACTDPA
);
1046 next_desc
= spider_net_read_reg(card
, SPIDER_NET_GDACNEXTDA
);
1051 hwd
= descr
->hwdescr
;
1052 off
= descr
- chain
->ring
;
1053 status
= hwd
->dmac_cmd_status
;
1055 if (descr
== chain
->head
)
1056 dev_info(dev
, "Chain head is at %d, head status=0x%x\n",
1059 if (curr_desc
== descr
->bus_addr
)
1060 dev_info(dev
, "HW curr desc (GDACTDPA) is at %d, status=0x%x\n",
1063 if (next_desc
== descr
->bus_addr
)
1064 dev_info(dev
, "HW next desc (GDACNEXTDA) is at %d, status=0x%x\n",
1067 if (hwd
->next_descr_addr
== 0)
1068 dev_info(dev
, "chain is cut at %d\n", off
);
1070 if (cstat
!= status
) {
1071 int from
= (chain
->num_desc
+ off
- cnt
) % chain
->num_desc
;
1072 int to
= (chain
->num_desc
+ off
- 1) % chain
->num_desc
;
1073 dev_info(dev
, "Have %d (from %d to %d) descrs "
1074 "with stat=0x%08x\n", cnt
, from
, to
, cstat
);
1081 descr
= descr
->next
;
1082 } while (descr
!= start
);
1084 dev_info(dev
, "Last %d descrs with stat=0x%08x "
1085 "for a total of %d descrs\n", cnt
, cstat
, tot
);
1088 /* Now dump the whole ring */
1092 struct spider_net_hw_descr
*hwd
= descr
->hwdescr
;
1093 status
= spider_net_get_descr_status(hwd
);
1094 cnt
= descr
- chain
->ring
;
1095 dev_info(dev
, "Descr %d stat=0x%08x skb=%p\n",
1096 cnt
, status
, descr
->skb
);
1097 dev_info(dev
, "bus addr=%08x buf addr=%08x sz=%d\n",
1098 descr
->bus_addr
, hwd
->buf_addr
, hwd
->buf_size
);
1099 dev_info(dev
, "next=%08x result sz=%d valid sz=%d\n",
1100 hwd
->next_descr_addr
, hwd
->result_size
,
1102 dev_info(dev
, "dmac=%08x data stat=%08x data err=%08x\n",
1103 hwd
->dmac_cmd_status
, hwd
->data_status
,
1105 dev_info(dev
, "\n");
1107 descr
= descr
->next
;
1108 } while (descr
!= start
);
1114 * spider_net_resync_head_ptr - Advance head ptr past empty descrs
1116 * If the driver fails to keep up and empty the queue, then the
1117 * hardware wil run out of room to put incoming packets. This
1118 * will cause the hardware to skip descrs that are full (instead
1119 * of halting/retrying). Thus, once the driver runs, it wil need
1120 * to "catch up" to where the hardware chain pointer is at.
1122 static void spider_net_resync_head_ptr(struct spider_net_card
*card
)
1124 unsigned long flags
;
1125 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
1126 struct spider_net_descr
*descr
;
1129 /* Advance head pointer past any empty descrs */
1130 descr
= chain
->head
;
1131 status
= spider_net_get_descr_status(descr
->hwdescr
);
1133 if (status
== SPIDER_NET_DESCR_NOT_IN_USE
)
1136 spin_lock_irqsave(&chain
->lock
, flags
);
1138 descr
= chain
->head
;
1139 status
= spider_net_get_descr_status(descr
->hwdescr
);
1140 for (i
=0; i
<chain
->num_desc
; i
++) {
1141 if (status
!= SPIDER_NET_DESCR_CARDOWNED
) break;
1142 descr
= descr
->next
;
1143 status
= spider_net_get_descr_status(descr
->hwdescr
);
1145 chain
->head
= descr
;
1147 spin_unlock_irqrestore(&chain
->lock
, flags
);
1150 static int spider_net_resync_tail_ptr(struct spider_net_card
*card
)
1152 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
1153 struct spider_net_descr
*descr
;
1156 /* Advance tail pointer past any empty and reaped descrs */
1157 descr
= chain
->tail
;
1158 status
= spider_net_get_descr_status(descr
->hwdescr
);
1160 for (i
=0; i
<chain
->num_desc
; i
++) {
1161 if ((status
!= SPIDER_NET_DESCR_CARDOWNED
) &&
1162 (status
!= SPIDER_NET_DESCR_NOT_IN_USE
)) break;
1163 descr
= descr
->next
;
1164 status
= spider_net_get_descr_status(descr
->hwdescr
);
1166 chain
->tail
= descr
;
1168 if ((i
== chain
->num_desc
) || (i
== 0))
1174 * spider_net_decode_one_descr - processes an RX descriptor
1175 * @card: card structure
1177 * Returns 1 if a packet has been sent to the stack, otherwise 0.
1179 * Processes an RX descriptor by iommu-unmapping the data buffer
1180 * and passing the packet up to the stack. This function is called
1181 * in softirq context, e.g. either bottom half from interrupt or
1182 * NAPI polling context.
1185 spider_net_decode_one_descr(struct spider_net_card
*card
)
1187 struct spider_net_descr_chain
*chain
= &card
->rx_chain
;
1188 struct spider_net_descr
*descr
= chain
->tail
;
1189 struct spider_net_hw_descr
*hwdescr
= descr
->hwdescr
;
1193 status
= spider_net_get_descr_status(hwdescr
);
1195 /* Nothing in the descriptor, or ring must be empty */
1196 if ((status
== SPIDER_NET_DESCR_CARDOWNED
) ||
1197 (status
== SPIDER_NET_DESCR_NOT_IN_USE
))
1200 /* descriptor definitively used -- move on tail */
1201 chain
->tail
= descr
->next
;
1203 /* unmap descriptor */
1204 hw_buf_addr
= hwdescr
->buf_addr
;
1205 hwdescr
->buf_addr
= 0xffffffff;
1206 pci_unmap_single(card
->pdev
, hw_buf_addr
,
1207 SPIDER_NET_MAX_FRAME
, PCI_DMA_FROMDEVICE
);
1209 if ( (status
== SPIDER_NET_DESCR_RESPONSE_ERROR
) ||
1210 (status
== SPIDER_NET_DESCR_PROTECTION_ERROR
) ||
1211 (status
== SPIDER_NET_DESCR_FORCE_END
) ) {
1212 if (netif_msg_rx_err(card
))
1213 dev_err(&card
->netdev
->dev
,
1214 "dropping RX descriptor with state %d\n", status
);
1215 card
->netdev_stats
.rx_dropped
++;
1219 if ( (status
!= SPIDER_NET_DESCR_COMPLETE
) &&
1220 (status
!= SPIDER_NET_DESCR_FRAME_END
) ) {
1221 if (netif_msg_rx_err(card
))
1222 dev_err(&card
->netdev
->dev
,
1223 "RX descriptor with unknown state %d\n", status
);
1224 card
->spider_stats
.rx_desc_unk_state
++;
1228 /* The cases we'll throw away the packet immediately */
1229 if (hwdescr
->data_error
& SPIDER_NET_DESTROY_RX_FLAGS
) {
1230 if (netif_msg_rx_err(card
))
1231 dev_err(&card
->netdev
->dev
,
1232 "error in received descriptor found, "
1233 "data_status=x%08x, data_error=x%08x\n",
1234 hwdescr
->data_status
, hwdescr
->data_error
);
1238 if (hwdescr
->dmac_cmd_status
& SPIDER_NET_DESCR_BAD_STATUS
) {
1239 dev_err(&card
->netdev
->dev
, "bad status, cmd_status=x%08x\n",
1240 hwdescr
->dmac_cmd_status
);
1241 pr_err("buf_addr=x%08x\n", hw_buf_addr
);
1242 pr_err("buf_size=x%08x\n", hwdescr
->buf_size
);
1243 pr_err("next_descr_addr=x%08x\n", hwdescr
->next_descr_addr
);
1244 pr_err("result_size=x%08x\n", hwdescr
->result_size
);
1245 pr_err("valid_size=x%08x\n", hwdescr
->valid_size
);
1246 pr_err("data_status=x%08x\n", hwdescr
->data_status
);
1247 pr_err("data_error=x%08x\n", hwdescr
->data_error
);
1248 pr_err("which=%ld\n", descr
- card
->rx_chain
.ring
);
1250 card
->spider_stats
.rx_desc_error
++;
1254 /* Ok, we've got a packet in descr */
1255 spider_net_pass_skb_up(descr
, card
);
1257 hwdescr
->dmac_cmd_status
= SPIDER_NET_DESCR_NOT_IN_USE
;
1261 if (netif_msg_rx_err(card
))
1262 show_rx_chain(card
);
1263 dev_kfree_skb_irq(descr
->skb
);
1265 hwdescr
->dmac_cmd_status
= SPIDER_NET_DESCR_NOT_IN_USE
;
1270 * spider_net_poll - NAPI poll function called by the stack to return packets
1271 * @netdev: interface device structure
1272 * @budget: number of packets we can pass to the stack at most
1274 * returns 0 if no more packets available to the driver/stack. Returns 1,
1275 * if the quota is exceeded, but the driver has still packets.
1277 * spider_net_poll returns all packets from the rx descriptors to the stack
1278 * (using netif_receive_skb). If all/enough packets are up, the driver
1279 * reenables interrupts and returns 0. If not, 1 is returned.
1281 static int spider_net_poll(struct napi_struct
*napi
, int budget
)
1283 struct spider_net_card
*card
= container_of(napi
, struct spider_net_card
, napi
);
1284 struct net_device
*netdev
= card
->netdev
;
1285 int packets_done
= 0;
1287 while (packets_done
< budget
) {
1288 if (!spider_net_decode_one_descr(card
))
1294 if ((packets_done
== 0) && (card
->num_rx_ints
!= 0)) {
1295 if (!spider_net_resync_tail_ptr(card
))
1296 packets_done
= budget
;
1297 spider_net_resync_head_ptr(card
);
1299 card
->num_rx_ints
= 0;
1301 spider_net_refill_rx_chain(card
);
1302 spider_net_enable_rxdmac(card
);
1304 spider_net_cleanup_tx_ring(card
);
1306 /* if all packets are in the stack, enable interrupts and return 0 */
1307 /* if not, return 1 */
1308 if (packets_done
< budget
) {
1309 netif_rx_complete(netdev
, napi
);
1310 spider_net_rx_irq_on(card
);
1311 card
->ignore_rx_ramfull
= 0;
1314 return packets_done
;
1318 * spider_net_get_stats - get interface statistics
1319 * @netdev: interface device structure
1321 * returns the interface statistics residing in the spider_net_card struct
1323 static struct net_device_stats
*
1324 spider_net_get_stats(struct net_device
*netdev
)
1326 struct spider_net_card
*card
= netdev_priv(netdev
);
1327 struct net_device_stats
*stats
= &card
->netdev_stats
;
1332 * spider_net_change_mtu - changes the MTU of an interface
1333 * @netdev: interface device structure
1334 * @new_mtu: new MTU value
1336 * returns 0 on success, <0 on failure
1339 spider_net_change_mtu(struct net_device
*netdev
, int new_mtu
)
1341 /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
1342 * and mtu is outbound only anyway */
1343 if ( (new_mtu
< SPIDER_NET_MIN_MTU
) ||
1344 (new_mtu
> SPIDER_NET_MAX_MTU
) )
1346 netdev
->mtu
= new_mtu
;
1351 * spider_net_set_mac - sets the MAC of an interface
1352 * @netdev: interface device structure
1353 * @ptr: pointer to new MAC address
1355 * Returns 0 on success, <0 on failure. Currently, we don't support this
1356 * and will always return EOPNOTSUPP.
1359 spider_net_set_mac(struct net_device
*netdev
, void *p
)
1361 struct spider_net_card
*card
= netdev_priv(netdev
);
1362 u32 macl
, macu
, regvalue
;
1363 struct sockaddr
*addr
= p
;
1365 if (!is_valid_ether_addr(addr
->sa_data
))
1366 return -EADDRNOTAVAIL
;
1368 /* switch off GMACTPE and GMACRPE */
1369 regvalue
= spider_net_read_reg(card
, SPIDER_NET_GMACOPEMD
);
1370 regvalue
&= ~((1 << 5) | (1 << 6));
1371 spider_net_write_reg(card
, SPIDER_NET_GMACOPEMD
, regvalue
);
1374 macu
= (addr
->sa_data
[0]<<24) + (addr
->sa_data
[1]<<16) +
1375 (addr
->sa_data
[2]<<8) + (addr
->sa_data
[3]);
1376 macl
= (addr
->sa_data
[4]<<8) + (addr
->sa_data
[5]);
1377 spider_net_write_reg(card
, SPIDER_NET_GMACUNIMACU
, macu
);
1378 spider_net_write_reg(card
, SPIDER_NET_GMACUNIMACL
, macl
);
1380 /* switch GMACTPE and GMACRPE back on */
1381 regvalue
= spider_net_read_reg(card
, SPIDER_NET_GMACOPEMD
);
1382 regvalue
|= ((1 << 5) | (1 << 6));
1383 spider_net_write_reg(card
, SPIDER_NET_GMACOPEMD
, regvalue
);
1385 spider_net_set_promisc(card
);
1387 /* look up, whether we have been successful */
1388 if (spider_net_get_mac_address(netdev
))
1389 return -EADDRNOTAVAIL
;
1390 if (memcmp(netdev
->dev_addr
,addr
->sa_data
,netdev
->addr_len
))
1391 return -EADDRNOTAVAIL
;
1397 * spider_net_link_reset
1398 * @netdev: net device structure
1400 * This is called when the PHY_LINK signal is asserted. For the blade this is
1401 * not connected so we should never get here.
1405 spider_net_link_reset(struct net_device
*netdev
)
1408 struct spider_net_card
*card
= netdev_priv(netdev
);
1410 del_timer_sync(&card
->aneg_timer
);
1412 /* clear interrupt, block further interrupts */
1413 spider_net_write_reg(card
, SPIDER_NET_GMACST
,
1414 spider_net_read_reg(card
, SPIDER_NET_GMACST
));
1415 spider_net_write_reg(card
, SPIDER_NET_GMACINTEN
, 0);
1417 /* reset phy and setup aneg */
1418 spider_net_setup_aneg(card
);
1419 mod_timer(&card
->aneg_timer
, jiffies
+ SPIDER_NET_ANEG_TIMER
);
1424 * spider_net_handle_error_irq - handles errors raised by an interrupt
1425 * @card: card structure
1426 * @status_reg: interrupt status register 0 (GHIINT0STS)
1428 * spider_net_handle_error_irq treats or ignores all error conditions
1429 * found when an interrupt is presented
1432 spider_net_handle_error_irq(struct spider_net_card
*card
, u32 status_reg
)
1434 u32 error_reg1
, error_reg2
;
1438 error_reg1
= spider_net_read_reg(card
, SPIDER_NET_GHIINT1STS
);
1439 error_reg2
= spider_net_read_reg(card
, SPIDER_NET_GHIINT2STS
);
1441 error_reg1
&= SPIDER_NET_INT1_MASK_VALUE
;
1442 error_reg2
&= SPIDER_NET_INT2_MASK_VALUE
;
1444 /* check GHIINT0STS ************************************/
1446 for (i
= 0; i
< 32; i
++)
1447 if (status_reg
& (1<<i
))
1450 /* let error_reg1 and error_reg2 evaluation decide, what to do
1451 case SPIDER_NET_PHYINT:
1452 case SPIDER_NET_GMAC2INT:
1453 case SPIDER_NET_GMAC1INT:
1454 case SPIDER_NET_GFIFOINT:
1455 case SPIDER_NET_DMACINT:
1456 case SPIDER_NET_GSYSINT:
1459 case SPIDER_NET_GIPSINT
:
1463 case SPIDER_NET_GPWOPCMPINT
:
1464 /* PHY write operation completed */
1467 case SPIDER_NET_GPROPCMPINT
:
1468 /* PHY read operation completed */
1469 /* we don't use semaphores, as we poll for the completion
1470 * of the read operation in spider_net_read_phy. Should take
1474 case SPIDER_NET_GPWFFINT
:
1475 /* PHY command queue full */
1476 if (netif_msg_intr(card
))
1477 dev_err(&card
->netdev
->dev
, "PHY write queue full\n");
1481 /* case SPIDER_NET_GRMDADRINT: not used. print a message */
1482 /* case SPIDER_NET_GRMARPINT: not used. print a message */
1483 /* case SPIDER_NET_GRMMPINT: not used. print a message */
1485 case SPIDER_NET_GDTDEN0INT
:
1486 /* someone has set TX_DMA_EN to 0 */
1490 case SPIDER_NET_GDDDEN0INT
: /* fallthrough */
1491 case SPIDER_NET_GDCDEN0INT
: /* fallthrough */
1492 case SPIDER_NET_GDBDEN0INT
: /* fallthrough */
1493 case SPIDER_NET_GDADEN0INT
:
1494 /* someone has set RX_DMA_EN to 0 */
1499 case SPIDER_NET_GDDFDCINT
:
1500 case SPIDER_NET_GDCFDCINT
:
1501 case SPIDER_NET_GDBFDCINT
:
1502 case SPIDER_NET_GDAFDCINT
:
1503 /* case SPIDER_NET_GDNMINT: not used. print a message */
1504 /* case SPIDER_NET_GCNMINT: not used. print a message */
1505 /* case SPIDER_NET_GBNMINT: not used. print a message */
1506 /* case SPIDER_NET_GANMINT: not used. print a message */
1507 /* case SPIDER_NET_GRFNMINT: not used. print a message */
1512 case SPIDER_NET_GDTFDCINT
:
1515 case SPIDER_NET_GTTEDINT
:
1518 case SPIDER_NET_GDTDCEINT
:
1519 /* chain end. If a descriptor should be sent, kick off
1521 if (card->tx_chain.tail != card->tx_chain.head)
1522 spider_net_kick_tx_dma(card);
1527 /* case SPIDER_NET_G1TMCNTINT: not used. print a message */
1528 /* case SPIDER_NET_GFREECNTINT: not used. print a message */
1531 /* check GHIINT1STS ************************************/
1533 for (i
= 0; i
< 32; i
++)
1534 if (error_reg1
& (1<<i
))
1537 case SPIDER_NET_GTMFLLINT
:
1538 /* TX RAM full may happen on a usual case.
1539 * Logging is not needed. */
1542 case SPIDER_NET_GRFDFLLINT
: /* fallthrough */
1543 case SPIDER_NET_GRFCFLLINT
: /* fallthrough */
1544 case SPIDER_NET_GRFBFLLINT
: /* fallthrough */
1545 case SPIDER_NET_GRFAFLLINT
: /* fallthrough */
1546 case SPIDER_NET_GRMFLLINT
:
1547 /* Could happen when rx chain is full */
1548 if (card
->ignore_rx_ramfull
== 0) {
1549 card
->ignore_rx_ramfull
= 1;
1550 spider_net_resync_head_ptr(card
);
1551 spider_net_refill_rx_chain(card
);
1552 spider_net_enable_rxdmac(card
);
1553 card
->num_rx_ints
++;
1554 netif_rx_schedule(card
->netdev
,
1560 /* case SPIDER_NET_GTMSHTINT: problem, print a message */
1561 case SPIDER_NET_GDTINVDINT
:
1562 /* allrighty. tx from previous descr ok */
1567 case SPIDER_NET_GDDDCEINT
: /* fallthrough */
1568 case SPIDER_NET_GDCDCEINT
: /* fallthrough */
1569 case SPIDER_NET_GDBDCEINT
: /* fallthrough */
1570 case SPIDER_NET_GDADCEINT
:
1571 spider_net_resync_head_ptr(card
);
1572 spider_net_refill_rx_chain(card
);
1573 spider_net_enable_rxdmac(card
);
1574 card
->num_rx_ints
++;
1575 netif_rx_schedule(card
->netdev
,
1580 /* invalid descriptor */
1581 case SPIDER_NET_GDDINVDINT
: /* fallthrough */
1582 case SPIDER_NET_GDCINVDINT
: /* fallthrough */
1583 case SPIDER_NET_GDBINVDINT
: /* fallthrough */
1584 case SPIDER_NET_GDAINVDINT
:
1585 /* Could happen when rx chain is full */
1586 spider_net_resync_head_ptr(card
);
1587 spider_net_refill_rx_chain(card
);
1588 spider_net_enable_rxdmac(card
);
1589 card
->num_rx_ints
++;
1590 netif_rx_schedule(card
->netdev
,
1595 /* case SPIDER_NET_GDTRSERINT: problem, print a message */
1596 /* case SPIDER_NET_GDDRSERINT: problem, print a message */
1597 /* case SPIDER_NET_GDCRSERINT: problem, print a message */
1598 /* case SPIDER_NET_GDBRSERINT: problem, print a message */
1599 /* case SPIDER_NET_GDARSERINT: problem, print a message */
1600 /* case SPIDER_NET_GDSERINT: problem, print a message */
1601 /* case SPIDER_NET_GDTPTERINT: problem, print a message */
1602 /* case SPIDER_NET_GDDPTERINT: problem, print a message */
1603 /* case SPIDER_NET_GDCPTERINT: problem, print a message */
1604 /* case SPIDER_NET_GDBPTERINT: problem, print a message */
1605 /* case SPIDER_NET_GDAPTERINT: problem, print a message */
1611 /* check GHIINT2STS ************************************/
1613 for (i
= 0; i
< 32; i
++)
1614 if (error_reg2
& (1<<i
))
1617 /* there is nothing we can (want to) do at this time. Log a
1618 * message, we can switch on and off the specific values later on
1619 case SPIDER_NET_GPROPERINT:
1620 case SPIDER_NET_GMCTCRSNGINT:
1621 case SPIDER_NET_GMCTLCOLINT:
1622 case SPIDER_NET_GMCTTMOTINT:
1623 case SPIDER_NET_GMCRCAERINT:
1624 case SPIDER_NET_GMCRCALERINT:
1625 case SPIDER_NET_GMCRALNERINT:
1626 case SPIDER_NET_GMCROVRINT:
1627 case SPIDER_NET_GMCRRNTINT:
1628 case SPIDER_NET_GMCRRXERINT:
1629 case SPIDER_NET_GTITCSERINT:
1630 case SPIDER_NET_GTIFMTERINT:
1631 case SPIDER_NET_GTIPKTRVKINT:
1632 case SPIDER_NET_GTISPINGINT:
1633 case SPIDER_NET_GTISADNGINT:
1634 case SPIDER_NET_GTISPDNGINT:
1635 case SPIDER_NET_GRIFMTERINT:
1636 case SPIDER_NET_GRIPKTRVKINT:
1637 case SPIDER_NET_GRISPINGINT:
1638 case SPIDER_NET_GRISADNGINT:
1639 case SPIDER_NET_GRISPDNGINT:
1646 if ((show_error
) && (netif_msg_intr(card
)) && net_ratelimit())
1647 dev_err(&card
->netdev
->dev
, "Error interrupt, GHIINT0STS = 0x%08x, "
1648 "GHIINT1STS = 0x%08x, GHIINT2STS = 0x%08x\n",
1649 status_reg
, error_reg1
, error_reg2
);
1651 /* clear interrupt sources */
1652 spider_net_write_reg(card
, SPIDER_NET_GHIINT1STS
, error_reg1
);
1653 spider_net_write_reg(card
, SPIDER_NET_GHIINT2STS
, error_reg2
);
1657 * spider_net_interrupt - interrupt handler for spider_net
1658 * @irq: interupt number
1659 * @ptr: pointer to net_device
1660 * @regs: PU registers
1662 * returns IRQ_HANDLED, if interrupt was for driver, or IRQ_NONE, if no
1663 * interrupt found raised by card.
1665 * This is the interrupt handler, that turns off
1666 * interrupts for this device and makes the stack poll the driver
1669 spider_net_interrupt(int irq
, void *ptr
)
1671 struct net_device
*netdev
= ptr
;
1672 struct spider_net_card
*card
= netdev_priv(netdev
);
1675 status_reg
= spider_net_read_reg(card
, SPIDER_NET_GHIINT0STS
);
1676 status_reg
&= SPIDER_NET_INT0_MASK_VALUE
;
1681 if (status_reg
& SPIDER_NET_RXINT
) {
1682 spider_net_rx_irq_off(card
);
1683 netif_rx_schedule(netdev
, &card
->napi
);
1684 card
->num_rx_ints
++;
1686 if (status_reg
& SPIDER_NET_TXINT
)
1687 netif_rx_schedule(netdev
, &card
->napi
);
1689 if (status_reg
& SPIDER_NET_LINKINT
)
1690 spider_net_link_reset(netdev
);
1692 if (status_reg
& SPIDER_NET_ERRINT
)
1693 spider_net_handle_error_irq(card
, status_reg
);
1695 /* clear interrupt sources */
1696 spider_net_write_reg(card
, SPIDER_NET_GHIINT0STS
, status_reg
);
1701 #ifdef CONFIG_NET_POLL_CONTROLLER
1703 * spider_net_poll_controller - artificial interrupt for netconsole etc.
1704 * @netdev: interface device structure
1706 * see Documentation/networking/netconsole.txt
1709 spider_net_poll_controller(struct net_device
*netdev
)
1711 disable_irq(netdev
->irq
);
1712 spider_net_interrupt(netdev
->irq
, netdev
);
1713 enable_irq(netdev
->irq
);
1715 #endif /* CONFIG_NET_POLL_CONTROLLER */
1718 * spider_net_enable_interrupts - enable interrupts
1719 * @card: card structure
1721 * spider_net_enable_interrupt enables several interrupts
1724 spider_net_enable_interrupts(struct spider_net_card
*card
)
1726 spider_net_write_reg(card
, SPIDER_NET_GHIINT0MSK
,
1727 SPIDER_NET_INT0_MASK_VALUE
);
1728 spider_net_write_reg(card
, SPIDER_NET_GHIINT1MSK
,
1729 SPIDER_NET_INT1_MASK_VALUE
);
1730 spider_net_write_reg(card
, SPIDER_NET_GHIINT2MSK
,
1731 SPIDER_NET_INT2_MASK_VALUE
);
1735 * spider_net_disable_interrupts - disable interrupts
1736 * @card: card structure
1738 * spider_net_disable_interrupts disables all the interrupts
1741 spider_net_disable_interrupts(struct spider_net_card
*card
)
1743 spider_net_write_reg(card
, SPIDER_NET_GHIINT0MSK
, 0);
1744 spider_net_write_reg(card
, SPIDER_NET_GHIINT1MSK
, 0);
1745 spider_net_write_reg(card
, SPIDER_NET_GHIINT2MSK
, 0);
1746 spider_net_write_reg(card
, SPIDER_NET_GMACINTEN
, 0);
1750 * spider_net_init_card - initializes the card
1751 * @card: card structure
1753 * spider_net_init_card initializes the card so that other registers can
1757 spider_net_init_card(struct spider_net_card
*card
)
1759 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
1760 SPIDER_NET_CKRCTRL_STOP_VALUE
);
1762 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
1763 SPIDER_NET_CKRCTRL_RUN_VALUE
);
1765 /* trigger ETOMOD signal */
1766 spider_net_write_reg(card
, SPIDER_NET_GMACOPEMD
,
1767 spider_net_read_reg(card
, SPIDER_NET_GMACOPEMD
) | 0x4);
1769 spider_net_disable_interrupts(card
);
1773 * spider_net_enable_card - enables the card by setting all kinds of regs
1774 * @card: card structure
1776 * spider_net_enable_card sets a lot of SMMIO registers to enable the device
1779 spider_net_enable_card(struct spider_net_card
*card
)
1782 /* the following array consists of (register),(value) pairs
1783 * that are set in this function. A register of 0 ends the list */
1785 { SPIDER_NET_GRESUMINTNUM
, 0 },
1786 { SPIDER_NET_GREINTNUM
, 0 },
1788 /* set interrupt frame number registers */
1789 /* clear the single DMA engine registers first */
1790 { SPIDER_NET_GFAFRMNUM
, SPIDER_NET_GFXFRAMES_VALUE
},
1791 { SPIDER_NET_GFBFRMNUM
, SPIDER_NET_GFXFRAMES_VALUE
},
1792 { SPIDER_NET_GFCFRMNUM
, SPIDER_NET_GFXFRAMES_VALUE
},
1793 { SPIDER_NET_GFDFRMNUM
, SPIDER_NET_GFXFRAMES_VALUE
},
1794 /* then set, what we really need */
1795 { SPIDER_NET_GFFRMNUM
, SPIDER_NET_FRAMENUM_VALUE
},
1797 /* timer counter registers and stuff */
1798 { SPIDER_NET_GFREECNNUM
, 0 },
1799 { SPIDER_NET_GONETIMENUM
, 0 },
1800 { SPIDER_NET_GTOUTFRMNUM
, 0 },
1802 /* RX mode setting */
1803 { SPIDER_NET_GRXMDSET
, SPIDER_NET_RXMODE_VALUE
},
1804 /* TX mode setting */
1805 { SPIDER_NET_GTXMDSET
, SPIDER_NET_TXMODE_VALUE
},
1806 /* IPSEC mode setting */
1807 { SPIDER_NET_GIPSECINIT
, SPIDER_NET_IPSECINIT_VALUE
},
1809 { SPIDER_NET_GFTRESTRT
, SPIDER_NET_RESTART_VALUE
},
1811 { SPIDER_NET_GMRWOLCTRL
, 0 },
1812 { SPIDER_NET_GTESTMD
, 0x10000000 },
1813 { SPIDER_NET_GTTQMSK
, 0x00400040 },
1815 { SPIDER_NET_GMACINTEN
, 0 },
1817 /* flow control stuff */
1818 { SPIDER_NET_GMACAPAUSE
, SPIDER_NET_MACAPAUSE_VALUE
},
1819 { SPIDER_NET_GMACTXPAUSE
, SPIDER_NET_TXPAUSE_VALUE
},
1821 { SPIDER_NET_GMACBSTLMT
, SPIDER_NET_BURSTLMT_VALUE
},
1826 while (regs
[i
][0]) {
1827 spider_net_write_reg(card
, regs
[i
][0], regs
[i
][1]);
1831 /* clear unicast filter table entries 1 to 14 */
1832 for (i
= 1; i
<= 14; i
++) {
1833 spider_net_write_reg(card
,
1834 SPIDER_NET_GMRUAFILnR
+ i
* 8,
1836 spider_net_write_reg(card
,
1837 SPIDER_NET_GMRUAFILnR
+ i
* 8 + 4,
1841 spider_net_write_reg(card
, SPIDER_NET_GMRUA0FIL15R
, 0x08080000);
1843 spider_net_write_reg(card
, SPIDER_NET_ECMODE
, SPIDER_NET_ECMODE_VALUE
);
1845 /* set chain tail adress for RX chains and
1847 spider_net_enable_rxchtails(card
);
1848 spider_net_enable_rxdmac(card
);
1850 spider_net_write_reg(card
, SPIDER_NET_GRXDMAEN
, SPIDER_NET_WOL_VALUE
);
1852 spider_net_write_reg(card
, SPIDER_NET_GMACLENLMT
,
1853 SPIDER_NET_LENLMT_VALUE
);
1854 spider_net_write_reg(card
, SPIDER_NET_GMACOPEMD
,
1855 SPIDER_NET_OPMODE_VALUE
);
1857 spider_net_write_reg(card
, SPIDER_NET_GDTDMACCNTR
,
1858 SPIDER_NET_GDTBSTA
);
1862 * spider_net_download_firmware - loads firmware into the adapter
1863 * @card: card structure
1864 * @firmware_ptr: pointer to firmware data
1866 * spider_net_download_firmware loads the firmware data into the
1867 * adapter. It assumes the length etc. to be allright.
1870 spider_net_download_firmware(struct spider_net_card
*card
,
1871 const void *firmware_ptr
)
1874 const u32
*fw_ptr
= firmware_ptr
;
1876 /* stop sequencers */
1877 spider_net_write_reg(card
, SPIDER_NET_GSINIT
,
1878 SPIDER_NET_STOP_SEQ_VALUE
);
1880 for (sequencer
= 0; sequencer
< SPIDER_NET_FIRMWARE_SEQS
;
1882 spider_net_write_reg(card
,
1883 SPIDER_NET_GSnPRGADR
+ sequencer
* 8, 0);
1884 for (i
= 0; i
< SPIDER_NET_FIRMWARE_SEQWORDS
; i
++) {
1885 spider_net_write_reg(card
, SPIDER_NET_GSnPRGDAT
+
1886 sequencer
* 8, *fw_ptr
);
1891 if (spider_net_read_reg(card
, SPIDER_NET_GSINIT
))
1894 spider_net_write_reg(card
, SPIDER_NET_GSINIT
,
1895 SPIDER_NET_RUN_SEQ_VALUE
);
1901 * spider_net_init_firmware - reads in firmware parts
1902 * @card: card structure
1904 * Returns 0 on success, <0 on failure
1906 * spider_net_init_firmware opens the sequencer firmware and does some basic
1907 * checks. This function opens and releases the firmware structure. A call
1908 * to download the firmware is performed before the release.
1912 * spider_fw.bin is expected to be a file containing 6*1024*4 bytes, 4k being
1913 * the program for each sequencer. Use the command
1914 * tail -q -n +2 Seq_code1_0x088.txt Seq_code2_0x090.txt \
1915 * Seq_code3_0x098.txt Seq_code4_0x0A0.txt Seq_code5_0x0A8.txt \
1916 * Seq_code6_0x0B0.txt | xxd -r -p -c4 > spider_fw.bin
1918 * to generate spider_fw.bin, if you have sequencer programs with something
1919 * like the following contents for each sequencer:
1920 * <ONE LINE COMMENT>
1921 * <FIRST 4-BYTES-WORD FOR SEQUENCER>
1922 * <SECOND 4-BYTES-WORD FOR SEQUENCER>
1924 * <1024th 4-BYTES-WORD FOR SEQUENCER>
1927 spider_net_init_firmware(struct spider_net_card
*card
)
1929 struct firmware
*firmware
= NULL
;
1930 struct device_node
*dn
;
1931 const u8
*fw_prop
= NULL
;
1935 if (request_firmware((const struct firmware
**)&firmware
,
1936 SPIDER_NET_FIRMWARE_NAME
, &card
->pdev
->dev
) == 0) {
1937 if ( (firmware
->size
!= SPIDER_NET_FIRMWARE_LEN
) &&
1938 netif_msg_probe(card
) ) {
1939 dev_err(&card
->netdev
->dev
,
1940 "Incorrect size of spidernet firmware in " \
1941 "filesystem. Looking in host firmware...\n");
1944 err
= spider_net_download_firmware(card
, firmware
->data
);
1946 release_firmware(firmware
);
1954 dn
= pci_device_to_OF_node(card
->pdev
);
1958 fw_prop
= of_get_property(dn
, "firmware", &fw_size
);
1962 if ( (fw_size
!= SPIDER_NET_FIRMWARE_LEN
) &&
1963 netif_msg_probe(card
) ) {
1964 dev_err(&card
->netdev
->dev
,
1965 "Incorrect size of spidernet firmware in host firmware\n");
1969 err
= spider_net_download_firmware(card
, fw_prop
);
1974 if (netif_msg_probe(card
))
1975 dev_err(&card
->netdev
->dev
,
1976 "Couldn't find spidernet firmware in filesystem " \
1977 "or host firmware\n");
1982 * spider_net_open - called upon ifonfig up
1983 * @netdev: interface device structure
1985 * returns 0 on success, <0 on failure
1987 * spider_net_open allocates all the descriptors and memory needed for
1988 * operation, sets up multicast list and enables interrupts
1991 spider_net_open(struct net_device
*netdev
)
1993 struct spider_net_card
*card
= netdev_priv(netdev
);
1996 result
= spider_net_init_firmware(card
);
1998 goto init_firmware_failed
;
2000 /* start probing with copper */
2001 spider_net_setup_aneg(card
);
2002 if (card
->phy
.def
->phy_id
)
2003 mod_timer(&card
->aneg_timer
, jiffies
+ SPIDER_NET_ANEG_TIMER
);
2005 result
= spider_net_init_chain(card
, &card
->tx_chain
);
2007 goto alloc_tx_failed
;
2008 card
->low_watermark
= NULL
;
2010 result
= spider_net_init_chain(card
, &card
->rx_chain
);
2012 goto alloc_rx_failed
;
2014 /* Allocate rx skbs */
2015 if (spider_net_alloc_rx_skbs(card
))
2016 goto alloc_skbs_failed
;
2018 spider_net_set_multi(netdev
);
2020 /* further enhancement: setup hw vlan, if needed */
2023 if (request_irq(netdev
->irq
, spider_net_interrupt
,
2024 IRQF_SHARED
, netdev
->name
, netdev
))
2025 goto register_int_failed
;
2027 spider_net_enable_card(card
);
2029 netif_start_queue(netdev
);
2030 netif_carrier_on(netdev
);
2031 napi_enable(&card
->napi
);
2033 spider_net_enable_interrupts(card
);
2037 register_int_failed
:
2038 spider_net_free_rx_chain_contents(card
);
2040 spider_net_free_chain(card
, &card
->rx_chain
);
2042 spider_net_free_chain(card
, &card
->tx_chain
);
2044 del_timer_sync(&card
->aneg_timer
);
2045 init_firmware_failed
:
2050 * spider_net_link_phy
2051 * @data: used for pointer to card structure
2054 static void spider_net_link_phy(unsigned long data
)
2056 struct spider_net_card
*card
= (struct spider_net_card
*)data
;
2057 struct mii_phy
*phy
= &card
->phy
;
2059 /* if link didn't come up after SPIDER_NET_ANEG_TIMEOUT tries, setup phy again */
2060 if (card
->aneg_count
> SPIDER_NET_ANEG_TIMEOUT
) {
2062 pr_info("%s: link is down trying to bring it up\n", card
->netdev
->name
);
2064 switch (card
->medium
) {
2065 case BCM54XX_COPPER
:
2066 /* enable fiber with autonegotiation first */
2067 if (phy
->def
->ops
->enable_fiber
)
2068 phy
->def
->ops
->enable_fiber(phy
, 1);
2069 card
->medium
= BCM54XX_FIBER
;
2073 /* fiber didn't come up, try to disable fiber autoneg */
2074 if (phy
->def
->ops
->enable_fiber
)
2075 phy
->def
->ops
->enable_fiber(phy
, 0);
2076 card
->medium
= BCM54XX_UNKNOWN
;
2079 case BCM54XX_UNKNOWN
:
2080 /* copper, fiber with and without failed,
2081 * retry from beginning */
2082 spider_net_setup_aneg(card
);
2083 card
->medium
= BCM54XX_COPPER
;
2087 card
->aneg_count
= 0;
2088 mod_timer(&card
->aneg_timer
, jiffies
+ SPIDER_NET_ANEG_TIMER
);
2092 /* link still not up, try again later */
2093 if (!(phy
->def
->ops
->poll_link(phy
))) {
2095 mod_timer(&card
->aneg_timer
, jiffies
+ SPIDER_NET_ANEG_TIMER
);
2099 /* link came up, get abilities */
2100 phy
->def
->ops
->read_link(phy
);
2102 spider_net_write_reg(card
, SPIDER_NET_GMACST
,
2103 spider_net_read_reg(card
, SPIDER_NET_GMACST
));
2104 spider_net_write_reg(card
, SPIDER_NET_GMACINTEN
, 0x4);
2106 if (phy
->speed
== 1000)
2107 spider_net_write_reg(card
, SPIDER_NET_GMACMODE
, 0x00000001);
2109 spider_net_write_reg(card
, SPIDER_NET_GMACMODE
, 0);
2111 card
->aneg_count
= 0;
2113 pr_debug("Found %s with %i Mbps, %s-duplex %sautoneg.\n",
2114 phy
->def
->name
, phy
->speed
, phy
->duplex
==1 ? "Full" : "Half",
2115 phy
->autoneg
==1 ? "" : "no ");
2121 * spider_net_setup_phy - setup PHY
2122 * @card: card structure
2124 * returns 0 on success, <0 on failure
2126 * spider_net_setup_phy is used as part of spider_net_probe.
2129 spider_net_setup_phy(struct spider_net_card
*card
)
2131 struct mii_phy
*phy
= &card
->phy
;
2133 spider_net_write_reg(card
, SPIDER_NET_GDTDMASEL
,
2134 SPIDER_NET_DMASEL_VALUE
);
2135 spider_net_write_reg(card
, SPIDER_NET_GPCCTRL
,
2136 SPIDER_NET_PHY_CTRL_VALUE
);
2138 phy
->dev
= card
->netdev
;
2139 phy
->mdio_read
= spider_net_read_phy
;
2140 phy
->mdio_write
= spider_net_write_phy
;
2142 for (phy
->mii_id
= 1; phy
->mii_id
<= 31; phy
->mii_id
++) {
2144 id
= spider_net_read_phy(card
->netdev
, phy
->mii_id
, MII_BMSR
);
2145 if (id
!= 0x0000 && id
!= 0xffff) {
2146 if (!mii_phy_probe(phy
, phy
->mii_id
)) {
2147 pr_info("Found %s.\n", phy
->def
->name
);
2157 * spider_net_workaround_rxramfull - work around firmware bug
2158 * @card: card structure
2163 spider_net_workaround_rxramfull(struct spider_net_card
*card
)
2165 int i
, sequencer
= 0;
2168 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
2169 SPIDER_NET_CKRCTRL_RUN_VALUE
);
2171 /* empty sequencer data */
2172 for (sequencer
= 0; sequencer
< SPIDER_NET_FIRMWARE_SEQS
;
2174 spider_net_write_reg(card
, SPIDER_NET_GSnPRGADR
+
2175 sequencer
* 8, 0x0);
2176 for (i
= 0; i
< SPIDER_NET_FIRMWARE_SEQWORDS
; i
++) {
2177 spider_net_write_reg(card
, SPIDER_NET_GSnPRGDAT
+
2178 sequencer
* 8, 0x0);
2182 /* set sequencer operation */
2183 spider_net_write_reg(card
, SPIDER_NET_GSINIT
, 0x000000fe);
2186 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
2187 SPIDER_NET_CKRCTRL_STOP_VALUE
);
2191 * spider_net_stop - called upon ifconfig down
2192 * @netdev: interface device structure
2197 spider_net_stop(struct net_device
*netdev
)
2199 struct spider_net_card
*card
= netdev_priv(netdev
);
2201 napi_disable(&card
->napi
);
2202 netif_carrier_off(netdev
);
2203 netif_stop_queue(netdev
);
2204 del_timer_sync(&card
->tx_timer
);
2205 del_timer_sync(&card
->aneg_timer
);
2207 spider_net_disable_interrupts(card
);
2209 free_irq(netdev
->irq
, netdev
);
2211 spider_net_write_reg(card
, SPIDER_NET_GDTDMACCNTR
,
2212 SPIDER_NET_DMA_TX_FEND_VALUE
);
2214 /* turn off DMA, force end */
2215 spider_net_disable_rxdmac(card
);
2217 /* release chains */
2218 spider_net_release_tx_chain(card
, 1);
2219 spider_net_free_rx_chain_contents(card
);
2221 spider_net_free_chain(card
, &card
->tx_chain
);
2222 spider_net_free_chain(card
, &card
->rx_chain
);
2228 * spider_net_tx_timeout_task - task scheduled by the watchdog timeout
2229 * function (to be called not under interrupt status)
2230 * @data: data, is interface device structure
2232 * called as task when tx hangs, resets interface (if interface is up)
2235 spider_net_tx_timeout_task(struct work_struct
*work
)
2237 struct spider_net_card
*card
=
2238 container_of(work
, struct spider_net_card
, tx_timeout_task
);
2239 struct net_device
*netdev
= card
->netdev
;
2241 if (!(netdev
->flags
& IFF_UP
))
2244 netif_device_detach(netdev
);
2245 spider_net_stop(netdev
);
2247 spider_net_workaround_rxramfull(card
);
2248 spider_net_init_card(card
);
2250 if (spider_net_setup_phy(card
))
2253 spider_net_open(netdev
);
2254 spider_net_kick_tx_dma(card
);
2255 netif_device_attach(netdev
);
2258 atomic_dec(&card
->tx_timeout_task_counter
);
2262 * spider_net_tx_timeout - called when the tx timeout watchdog kicks in.
2263 * @netdev: interface device structure
2265 * called, if tx hangs. Schedules a task that resets the interface
2268 spider_net_tx_timeout(struct net_device
*netdev
)
2270 struct spider_net_card
*card
;
2272 card
= netdev_priv(netdev
);
2273 atomic_inc(&card
->tx_timeout_task_counter
);
2274 if (netdev
->flags
& IFF_UP
)
2275 schedule_work(&card
->tx_timeout_task
);
2277 atomic_dec(&card
->tx_timeout_task_counter
);
2278 card
->spider_stats
.tx_timeouts
++;
2282 * spider_net_setup_netdev_ops - initialization of net_device operations
2283 * @netdev: net_device structure
2285 * fills out function pointers in the net_device structure
2288 spider_net_setup_netdev_ops(struct net_device
*netdev
)
2290 netdev
->open
= &spider_net_open
;
2291 netdev
->stop
= &spider_net_stop
;
2292 netdev
->hard_start_xmit
= &spider_net_xmit
;
2293 netdev
->get_stats
= &spider_net_get_stats
;
2294 netdev
->set_multicast_list
= &spider_net_set_multi
;
2295 netdev
->set_mac_address
= &spider_net_set_mac
;
2296 netdev
->change_mtu
= &spider_net_change_mtu
;
2297 netdev
->do_ioctl
= &spider_net_do_ioctl
;
2299 netdev
->tx_timeout
= &spider_net_tx_timeout
;
2300 netdev
->watchdog_timeo
= SPIDER_NET_WATCHDOG_TIMEOUT
;
2302 #ifdef CONFIG_NET_POLL_CONTROLLER
2303 /* poll controller */
2304 netdev
->poll_controller
= &spider_net_poll_controller
;
2305 #endif /* CONFIG_NET_POLL_CONTROLLER */
2307 netdev
->ethtool_ops
= &spider_net_ethtool_ops
;
2311 * spider_net_setup_netdev - initialization of net_device
2312 * @card: card structure
2314 * Returns 0 on success or <0 on failure
2316 * spider_net_setup_netdev initializes the net_device structure
2319 spider_net_setup_netdev(struct spider_net_card
*card
)
2322 struct net_device
*netdev
= card
->netdev
;
2323 struct device_node
*dn
;
2324 struct sockaddr addr
;
2327 SET_NETDEV_DEV(netdev
, &card
->pdev
->dev
);
2329 pci_set_drvdata(card
->pdev
, netdev
);
2331 init_timer(&card
->tx_timer
);
2332 card
->tx_timer
.function
=
2333 (void (*)(unsigned long)) spider_net_cleanup_tx_ring
;
2334 card
->tx_timer
.data
= (unsigned long) card
;
2335 netdev
->irq
= card
->pdev
->irq
;
2337 card
->aneg_count
= 0;
2338 init_timer(&card
->aneg_timer
);
2339 card
->aneg_timer
.function
= spider_net_link_phy
;
2340 card
->aneg_timer
.data
= (unsigned long) card
;
2342 card
->options
.rx_csum
= SPIDER_NET_RX_CSUM_DEFAULT
;
2344 netif_napi_add(netdev
, &card
->napi
,
2345 spider_net_poll
, SPIDER_NET_NAPI_WEIGHT
);
2347 spider_net_setup_netdev_ops(netdev
);
2349 netdev
->features
= NETIF_F_IP_CSUM
| NETIF_F_LLTX
;
2350 /* some time: NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX |
2351 * NETIF_F_HW_VLAN_FILTER */
2353 netdev
->irq
= card
->pdev
->irq
;
2354 card
->num_rx_ints
= 0;
2355 card
->ignore_rx_ramfull
= 0;
2357 dn
= pci_device_to_OF_node(card
->pdev
);
2361 mac
= of_get_property(dn
, "local-mac-address", NULL
);
2364 memcpy(addr
.sa_data
, mac
, ETH_ALEN
);
2366 result
= spider_net_set_mac(netdev
, &addr
);
2367 if ((result
) && (netif_msg_probe(card
)))
2368 dev_err(&card
->netdev
->dev
,
2369 "Failed to set MAC address: %i\n", result
);
2371 result
= register_netdev(netdev
);
2373 if (netif_msg_probe(card
))
2374 dev_err(&card
->netdev
->dev
,
2375 "Couldn't register net_device: %i\n", result
);
2379 if (netif_msg_probe(card
))
2380 pr_info("Initialized device %s.\n", netdev
->name
);
2386 * spider_net_alloc_card - allocates net_device and card structure
2388 * returns the card structure or NULL in case of errors
2390 * the card and net_device structures are linked to each other
2392 static struct spider_net_card
*
2393 spider_net_alloc_card(void)
2395 struct net_device
*netdev
;
2396 struct spider_net_card
*card
;
2399 alloc_size
= sizeof(struct spider_net_card
) +
2400 (tx_descriptors
+ rx_descriptors
) * sizeof(struct spider_net_descr
);
2401 netdev
= alloc_etherdev(alloc_size
);
2405 card
= netdev_priv(netdev
);
2406 card
->netdev
= netdev
;
2407 card
->msg_enable
= SPIDER_NET_DEFAULT_MSG
;
2408 INIT_WORK(&card
->tx_timeout_task
, spider_net_tx_timeout_task
);
2409 init_waitqueue_head(&card
->waitq
);
2410 atomic_set(&card
->tx_timeout_task_counter
, 0);
2412 card
->rx_chain
.num_desc
= rx_descriptors
;
2413 card
->rx_chain
.ring
= card
->darray
;
2414 card
->tx_chain
.num_desc
= tx_descriptors
;
2415 card
->tx_chain
.ring
= card
->darray
+ rx_descriptors
;
2421 * spider_net_undo_pci_setup - releases PCI ressources
2422 * @card: card structure
2424 * spider_net_undo_pci_setup releases the mapped regions
2427 spider_net_undo_pci_setup(struct spider_net_card
*card
)
2429 iounmap(card
->regs
);
2430 pci_release_regions(card
->pdev
);
2434 * spider_net_setup_pci_dev - sets up the device in terms of PCI operations
2435 * @card: card structure
2438 * Returns the card structure or NULL if any errors occur
2440 * spider_net_setup_pci_dev initializes pdev and together with the
2441 * functions called in spider_net_open configures the device so that
2442 * data can be transferred over it
2443 * The net_device structure is attached to the card structure, if the
2444 * function returns without error.
2446 static struct spider_net_card
*
2447 spider_net_setup_pci_dev(struct pci_dev
*pdev
)
2449 struct spider_net_card
*card
;
2450 unsigned long mmio_start
, mmio_len
;
2452 if (pci_enable_device(pdev
)) {
2453 dev_err(&pdev
->dev
, "Couldn't enable PCI device\n");
2457 if (!(pci_resource_flags(pdev
, 0) & IORESOURCE_MEM
)) {
2459 "Couldn't find proper PCI device base address.\n");
2460 goto out_disable_dev
;
2463 if (pci_request_regions(pdev
, spider_net_driver_name
)) {
2465 "Couldn't obtain PCI resources, aborting.\n");
2466 goto out_disable_dev
;
2469 pci_set_master(pdev
);
2471 card
= spider_net_alloc_card();
2474 "Couldn't allocate net_device structure, aborting.\n");
2475 goto out_release_regions
;
2479 /* fetch base address and length of first resource */
2480 mmio_start
= pci_resource_start(pdev
, 0);
2481 mmio_len
= pci_resource_len(pdev
, 0);
2483 card
->netdev
->mem_start
= mmio_start
;
2484 card
->netdev
->mem_end
= mmio_start
+ mmio_len
;
2485 card
->regs
= ioremap(mmio_start
, mmio_len
);
2489 "Couldn't obtain PCI resources, aborting.\n");
2490 goto out_release_regions
;
2495 out_release_regions
:
2496 pci_release_regions(pdev
);
2498 pci_disable_device(pdev
);
2499 pci_set_drvdata(pdev
, NULL
);
2504 * spider_net_probe - initialization of a device
2506 * @ent: entry in the device id list
2508 * Returns 0 on success, <0 on failure
2510 * spider_net_probe initializes pdev and registers a net_device
2511 * structure for it. After that, the device can be ifconfig'ed up
2513 static int __devinit
2514 spider_net_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
2517 struct spider_net_card
*card
;
2519 card
= spider_net_setup_pci_dev(pdev
);
2523 spider_net_workaround_rxramfull(card
);
2524 spider_net_init_card(card
);
2526 err
= spider_net_setup_phy(card
);
2530 err
= spider_net_setup_netdev(card
);
2537 spider_net_undo_pci_setup(card
);
2538 free_netdev(card
->netdev
);
2544 * spider_net_remove - removal of a device
2547 * Returns 0 on success, <0 on failure
2549 * spider_net_remove is called to remove the device and unregisters the
2552 static void __devexit
2553 spider_net_remove(struct pci_dev
*pdev
)
2555 struct net_device
*netdev
;
2556 struct spider_net_card
*card
;
2558 netdev
= pci_get_drvdata(pdev
);
2559 card
= netdev_priv(netdev
);
2561 wait_event(card
->waitq
,
2562 atomic_read(&card
->tx_timeout_task_counter
) == 0);
2564 unregister_netdev(netdev
);
2566 /* switch off card */
2567 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
2568 SPIDER_NET_CKRCTRL_STOP_VALUE
);
2569 spider_net_write_reg(card
, SPIDER_NET_CKRCTRL
,
2570 SPIDER_NET_CKRCTRL_RUN_VALUE
);
2572 spider_net_undo_pci_setup(card
);
2573 free_netdev(netdev
);
2576 static struct pci_driver spider_net_driver
= {
2577 .name
= spider_net_driver_name
,
2578 .id_table
= spider_net_pci_tbl
,
2579 .probe
= spider_net_probe
,
2580 .remove
= __devexit_p(spider_net_remove
)
2584 * spider_net_init - init function when the driver is loaded
2586 * spider_net_init registers the device driver
2588 static int __init
spider_net_init(void)
2590 printk(KERN_INFO
"Spidernet version %s.\n", VERSION
);
2592 if (rx_descriptors
< SPIDER_NET_RX_DESCRIPTORS_MIN
) {
2593 rx_descriptors
= SPIDER_NET_RX_DESCRIPTORS_MIN
;
2594 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors
);
2596 if (rx_descriptors
> SPIDER_NET_RX_DESCRIPTORS_MAX
) {
2597 rx_descriptors
= SPIDER_NET_RX_DESCRIPTORS_MAX
;
2598 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors
);
2600 if (tx_descriptors
< SPIDER_NET_TX_DESCRIPTORS_MIN
) {
2601 tx_descriptors
= SPIDER_NET_TX_DESCRIPTORS_MIN
;
2602 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors
);
2604 if (tx_descriptors
> SPIDER_NET_TX_DESCRIPTORS_MAX
) {
2605 tx_descriptors
= SPIDER_NET_TX_DESCRIPTORS_MAX
;
2606 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors
);
2609 return pci_register_driver(&spider_net_driver
);
2613 * spider_net_cleanup - exit function when driver is unloaded
2615 * spider_net_cleanup unregisters the device driver
2617 static void __exit
spider_net_cleanup(void)
2619 pci_unregister_driver(&spider_net_driver
);
2622 module_init(spider_net_init
);
2623 module_exit(spider_net_cleanup
);