1 /*******************************************************************************
3 Copyright(c) 2006 Tundra Semiconductor Corporation.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the Free
7 Software Foundation; either version 2 of the License, or (at your option)
10 This program is distributed in the hope that it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 You should have received a copy of the GNU General Public License along with
16 this program; if not, write to the Free Software Foundation, Inc., 59
17 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 *******************************************************************************/
21 /* This driver is based on the driver code originally developed
22 * for the Intel IOC80314 (ForestLake) Gigabit Ethernet by
23 * scott.wood@timesys.com * Copyright (C) 2003 TimeSys Corporation
25 * Currently changes from original version are:
26 * - porting to Tsi108-based platform and kernel 2.6 (kong.lai@tundra.com)
27 * - modifications to handle two ports independently and support for
28 * additional PHY devices (alexandre.bounine@tundra.com)
29 * - Get hardware information from platform device. (tie-fei.zang@freescale.com)
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/init.h>
36 #include <linux/net.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/skbuff.h>
40 #include <linux/slab.h>
41 #include <linux/spinlock.h>
42 #include <linux/delay.h>
43 #include <linux/crc32.h>
44 #include <linux/mii.h>
45 #include <linux/device.h>
46 #include <linux/pci.h>
47 #include <linux/rtnetlink.h>
48 #include <linux/timer.h>
49 #include <linux/platform_device.h>
51 #include <asm/system.h>
53 #include <asm/tsi108.h>
55 #include "tsi108_eth.h"
57 #define MII_READ_DELAY 10000 /* max link wait time in msec */
59 #define TSI108_RXRING_LEN 256
61 /* NOTE: The driver currently does not support receiving packets
62 * larger than the buffer size, so don't decrease this (unless you
63 * want to add such support).
65 #define TSI108_RXBUF_SIZE 1536
67 #define TSI108_TXRING_LEN 256
69 #define TSI108_TX_INT_FREQ 64
71 /* Check the phy status every half a second. */
72 #define CHECK_PHY_INTERVAL (HZ/2)
74 static int tsi108_init_one(struct platform_device
*pdev
);
75 static int tsi108_ether_remove(struct platform_device
*pdev
);
77 struct tsi108_prv_data
{
78 void __iomem
*regs
; /* Base of normal regs */
79 void __iomem
*phyregs
; /* Base of register bank used for PHY access */
81 struct net_device
*dev
;
82 struct napi_struct napi
;
84 unsigned int phy
; /* Index of PHY for this interface */
87 unsigned int phy_type
;
89 struct timer_list timer
;/* Timer that triggers the check phy function */
90 unsigned int rxtail
; /* Next entry in rxring to read */
91 unsigned int rxhead
; /* Next entry in rxring to give a new buffer */
92 unsigned int rxfree
; /* Number of free, allocated RX buffers */
94 unsigned int rxpending
; /* Non-zero if there are still descriptors
95 * to be processed from a previous descriptor
96 * interrupt condition that has been cleared */
98 unsigned int txtail
; /* Next TX descriptor to check status on */
99 unsigned int txhead
; /* Next TX descriptor to use */
101 /* Number of free TX descriptors. This could be calculated from
102 * rxhead and rxtail if one descriptor were left unused to disambiguate
103 * full and empty conditions, but it's simpler to just keep track
108 unsigned int phy_ok
; /* The PHY is currently powered on. */
110 /* PHY status (duplex is 1 for half, 2 for full,
111 * so that the default 0 indicates that neither has
112 * yet been configured). */
114 unsigned int link_up
;
120 struct sk_buff
*txskbs
[TSI108_TXRING_LEN
];
121 struct sk_buff
*rxskbs
[TSI108_RXRING_LEN
];
123 dma_addr_t txdma
, rxdma
;
125 /* txlock nests in misclock and phy_lock */
127 spinlock_t txlock
, misclock
;
129 /* stats is used to hold the upper bits of each hardware counter,
130 * and tmpstats is used to hold the full values for returning
131 * to the caller of get_stats(). They must be separate in case
132 * an overflow interrupt occurs before the stats are consumed.
135 struct net_device_stats stats
;
136 struct net_device_stats tmpstats
;
138 /* These stats are kept separate in hardware, thus require individual
139 * fields for handling carry. They are combined in get_stats.
142 unsigned long rx_fcs
; /* Add to rx_frame_errors */
143 unsigned long rx_short_fcs
; /* Add to rx_frame_errors */
144 unsigned long rx_long_fcs
; /* Add to rx_frame_errors */
145 unsigned long rx_underruns
; /* Add to rx_length_errors */
146 unsigned long rx_overruns
; /* Add to rx_length_errors */
148 unsigned long tx_coll_abort
; /* Add to tx_aborted_errors/collisions */
149 unsigned long tx_pause_drop
; /* Add to tx_aborted_errors */
151 unsigned long mc_hash
[16];
152 u32 msg_enable
; /* debug message level */
153 struct mii_if_info mii_if
;
154 unsigned int init_media
;
157 /* Structure for a device driver */
159 static struct platform_driver tsi_eth_driver
= {
160 .probe
= tsi108_init_one
,
161 .remove
= tsi108_ether_remove
,
163 .name
= "tsi-ethernet",
167 static void tsi108_timed_checker(unsigned long dev_ptr
);
169 static void dump_eth_one(struct net_device
*dev
)
171 struct tsi108_prv_data
*data
= netdev_priv(dev
);
173 printk("Dumping %s...\n", dev
->name
);
174 printk("intstat %x intmask %x phy_ok %d"
175 " link %d speed %d duplex %d\n",
176 TSI_READ(TSI108_EC_INTSTAT
),
177 TSI_READ(TSI108_EC_INTMASK
), data
->phy_ok
,
178 data
->link_up
, data
->speed
, data
->duplex
);
180 printk("TX: head %d, tail %d, free %d, stat %x, estat %x, err %x\n",
181 data
->txhead
, data
->txtail
, data
->txfree
,
182 TSI_READ(TSI108_EC_TXSTAT
),
183 TSI_READ(TSI108_EC_TXESTAT
),
184 TSI_READ(TSI108_EC_TXERR
));
186 printk("RX: head %d, tail %d, free %d, stat %x,"
187 " estat %x, err %x, pending %d\n\n",
188 data
->rxhead
, data
->rxtail
, data
->rxfree
,
189 TSI_READ(TSI108_EC_RXSTAT
),
190 TSI_READ(TSI108_EC_RXESTAT
),
191 TSI_READ(TSI108_EC_RXERR
), data
->rxpending
);
194 /* Synchronization is needed between the thread and up/down events.
195 * Note that the PHY is accessed through the same registers for both
196 * interfaces, so this can't be made interface-specific.
199 static DEFINE_SPINLOCK(phy_lock
);
201 static int tsi108_read_mii(struct tsi108_prv_data
*data
, int reg
)
205 TSI_WRITE_PHY(TSI108_MAC_MII_ADDR
,
206 (data
->phy
<< TSI108_MAC_MII_ADDR_PHY
) |
207 (reg
<< TSI108_MAC_MII_ADDR_REG
));
208 TSI_WRITE_PHY(TSI108_MAC_MII_CMD
, 0);
209 TSI_WRITE_PHY(TSI108_MAC_MII_CMD
, TSI108_MAC_MII_CMD_READ
);
210 for (i
= 0; i
< 100; i
++) {
211 if (!(TSI_READ_PHY(TSI108_MAC_MII_IND
) &
212 (TSI108_MAC_MII_IND_NOTVALID
| TSI108_MAC_MII_IND_BUSY
)))
220 return (TSI_READ_PHY(TSI108_MAC_MII_DATAIN
));
223 static void tsi108_write_mii(struct tsi108_prv_data
*data
,
227 TSI_WRITE_PHY(TSI108_MAC_MII_ADDR
,
228 (data
->phy
<< TSI108_MAC_MII_ADDR_PHY
) |
229 (reg
<< TSI108_MAC_MII_ADDR_REG
));
230 TSI_WRITE_PHY(TSI108_MAC_MII_DATAOUT
, val
);
232 if(!(TSI_READ_PHY(TSI108_MAC_MII_IND
) &
233 TSI108_MAC_MII_IND_BUSY
))
239 static int tsi108_mdio_read(struct net_device
*dev
, int addr
, int reg
)
241 struct tsi108_prv_data
*data
= netdev_priv(dev
);
242 return tsi108_read_mii(data
, reg
);
245 static void tsi108_mdio_write(struct net_device
*dev
, int addr
, int reg
, int val
)
247 struct tsi108_prv_data
*data
= netdev_priv(dev
);
248 tsi108_write_mii(data
, reg
, val
);
251 static inline void tsi108_write_tbi(struct tsi108_prv_data
*data
,
255 TSI_WRITE(TSI108_MAC_MII_ADDR
,
256 (0x1e << TSI108_MAC_MII_ADDR_PHY
)
257 | (reg
<< TSI108_MAC_MII_ADDR_REG
));
258 TSI_WRITE(TSI108_MAC_MII_DATAOUT
, val
);
260 if(!(TSI_READ(TSI108_MAC_MII_IND
) & TSI108_MAC_MII_IND_BUSY
))
264 printk(KERN_ERR
"%s function time out \n", __FUNCTION__
);
267 static int mii_speed(struct mii_if_info
*mii
)
269 int advert
, lpa
, val
, media
;
273 if (!mii_link_ok(mii
))
276 val
= (*mii
->mdio_read
) (mii
->dev
, mii
->phy_id
, MII_BMSR
);
277 if ((val
& BMSR_ANEGCOMPLETE
) == 0)
280 advert
= (*mii
->mdio_read
) (mii
->dev
, mii
->phy_id
, MII_ADVERTISE
);
281 lpa
= (*mii
->mdio_read
) (mii
->dev
, mii
->phy_id
, MII_LPA
);
282 media
= mii_nway_result(advert
& lpa
);
284 if (mii
->supports_gmii
)
285 lpa2
= mii
->mdio_read(mii
->dev
, mii
->phy_id
, MII_STAT1000
);
287 speed
= lpa2
& (LPA_1000FULL
| LPA_1000HALF
) ? 1000 :
288 (media
& (ADVERTISE_100FULL
| ADVERTISE_100HALF
) ? 100 : 10);
292 static void tsi108_check_phy(struct net_device
*dev
)
294 struct tsi108_prv_data
*data
= netdev_priv(dev
);
295 u32 mac_cfg2_reg
, portctrl_reg
;
300 spin_lock_irqsave(&phy_lock
, flags
);
305 duplex
= mii_check_media(&data
->mii_if
, netif_msg_link(data
), data
->init_media
);
306 data
->init_media
= 0;
308 if (netif_carrier_ok(dev
)) {
310 speed
= mii_speed(&data
->mii_if
);
312 if ((speed
!= data
->speed
) || duplex
) {
314 mac_cfg2_reg
= TSI_READ(TSI108_MAC_CFG2
);
315 portctrl_reg
= TSI_READ(TSI108_EC_PORTCTRL
);
317 mac_cfg2_reg
&= ~TSI108_MAC_CFG2_IFACE_MASK
;
320 mac_cfg2_reg
|= TSI108_MAC_CFG2_GIG
;
321 portctrl_reg
&= ~TSI108_EC_PORTCTRL_NOGIG
;
323 mac_cfg2_reg
|= TSI108_MAC_CFG2_NOGIG
;
324 portctrl_reg
|= TSI108_EC_PORTCTRL_NOGIG
;
329 if (data
->mii_if
.full_duplex
) {
330 mac_cfg2_reg
|= TSI108_MAC_CFG2_FULLDUPLEX
;
331 portctrl_reg
&= ~TSI108_EC_PORTCTRL_HALFDUPLEX
;
334 mac_cfg2_reg
&= ~TSI108_MAC_CFG2_FULLDUPLEX
;
335 portctrl_reg
|= TSI108_EC_PORTCTRL_HALFDUPLEX
;
339 TSI_WRITE(TSI108_MAC_CFG2
, mac_cfg2_reg
);
340 TSI_WRITE(TSI108_EC_PORTCTRL
, portctrl_reg
);
342 if (data
->link_up
== 0) {
343 /* The manual says it can take 3-4 usecs for the speed change
348 spin_lock(&data
->txlock
);
349 if (is_valid_ether_addr(dev
->dev_addr
) && data
->txfree
)
350 netif_wake_queue(dev
);
353 spin_unlock(&data
->txlock
);
358 if (data
->link_up
== 1) {
359 netif_stop_queue(dev
);
361 printk(KERN_NOTICE
"%s : link is down\n", dev
->name
);
369 spin_unlock_irqrestore(&phy_lock
, flags
);
373 tsi108_stat_carry_one(int carry
, int carry_bit
, int carry_shift
,
374 unsigned long *upper
)
376 if (carry
& carry_bit
)
377 *upper
+= carry_shift
;
380 static void tsi108_stat_carry(struct net_device
*dev
)
382 struct tsi108_prv_data
*data
= netdev_priv(dev
);
385 spin_lock_irq(&data
->misclock
);
387 carry1
= TSI_READ(TSI108_STAT_CARRY1
);
388 carry2
= TSI_READ(TSI108_STAT_CARRY2
);
390 TSI_WRITE(TSI108_STAT_CARRY1
, carry1
);
391 TSI_WRITE(TSI108_STAT_CARRY2
, carry2
);
393 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXBYTES
,
394 TSI108_STAT_RXBYTES_CARRY
, &data
->stats
.rx_bytes
);
396 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXPKTS
,
397 TSI108_STAT_RXPKTS_CARRY
,
398 &data
->stats
.rx_packets
);
400 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXFCS
,
401 TSI108_STAT_RXFCS_CARRY
, &data
->rx_fcs
);
403 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXMCAST
,
404 TSI108_STAT_RXMCAST_CARRY
,
405 &data
->stats
.multicast
);
407 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXALIGN
,
408 TSI108_STAT_RXALIGN_CARRY
,
409 &data
->stats
.rx_frame_errors
);
411 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXLENGTH
,
412 TSI108_STAT_RXLENGTH_CARRY
,
413 &data
->stats
.rx_length_errors
);
415 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXRUNT
,
416 TSI108_STAT_RXRUNT_CARRY
, &data
->rx_underruns
);
418 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXJUMBO
,
419 TSI108_STAT_RXJUMBO_CARRY
, &data
->rx_overruns
);
421 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXFRAG
,
422 TSI108_STAT_RXFRAG_CARRY
, &data
->rx_short_fcs
);
424 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXJABBER
,
425 TSI108_STAT_RXJABBER_CARRY
, &data
->rx_long_fcs
);
427 tsi108_stat_carry_one(carry1
, TSI108_STAT_CARRY1_RXDROP
,
428 TSI108_STAT_RXDROP_CARRY
,
429 &data
->stats
.rx_missed_errors
);
431 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXBYTES
,
432 TSI108_STAT_TXBYTES_CARRY
, &data
->stats
.tx_bytes
);
434 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXPKTS
,
435 TSI108_STAT_TXPKTS_CARRY
,
436 &data
->stats
.tx_packets
);
438 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXEXDEF
,
439 TSI108_STAT_TXEXDEF_CARRY
,
440 &data
->stats
.tx_aborted_errors
);
442 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXEXCOL
,
443 TSI108_STAT_TXEXCOL_CARRY
, &data
->tx_coll_abort
);
445 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXTCOL
,
446 TSI108_STAT_TXTCOL_CARRY
,
447 &data
->stats
.collisions
);
449 tsi108_stat_carry_one(carry2
, TSI108_STAT_CARRY2_TXPAUSE
,
450 TSI108_STAT_TXPAUSEDROP_CARRY
,
451 &data
->tx_pause_drop
);
453 spin_unlock_irq(&data
->misclock
);
456 /* Read a stat counter atomically with respect to carries.
457 * data->misclock must be held.
459 static inline unsigned long
460 tsi108_read_stat(struct tsi108_prv_data
* data
, int reg
, int carry_bit
,
461 int carry_shift
, unsigned long *upper
)
467 carryreg
= TSI108_STAT_CARRY1
;
469 carryreg
= TSI108_STAT_CARRY2
;
472 val
= TSI_READ(reg
) | *upper
;
474 /* Check to see if it overflowed, but the interrupt hasn't
475 * been serviced yet. If so, handle the carry here, and
479 if (unlikely(TSI_READ(carryreg
) & carry_bit
)) {
480 *upper
+= carry_shift
;
481 TSI_WRITE(carryreg
, carry_bit
);
488 static struct net_device_stats
*tsi108_get_stats(struct net_device
*dev
)
492 struct tsi108_prv_data
*data
= netdev_priv(dev
);
493 spin_lock_irq(&data
->misclock
);
495 data
->tmpstats
.rx_packets
=
496 tsi108_read_stat(data
, TSI108_STAT_RXPKTS
,
497 TSI108_STAT_CARRY1_RXPKTS
,
498 TSI108_STAT_RXPKTS_CARRY
, &data
->stats
.rx_packets
);
500 data
->tmpstats
.tx_packets
=
501 tsi108_read_stat(data
, TSI108_STAT_TXPKTS
,
502 TSI108_STAT_CARRY2_TXPKTS
,
503 TSI108_STAT_TXPKTS_CARRY
, &data
->stats
.tx_packets
);
505 data
->tmpstats
.rx_bytes
=
506 tsi108_read_stat(data
, TSI108_STAT_RXBYTES
,
507 TSI108_STAT_CARRY1_RXBYTES
,
508 TSI108_STAT_RXBYTES_CARRY
, &data
->stats
.rx_bytes
);
510 data
->tmpstats
.tx_bytes
=
511 tsi108_read_stat(data
, TSI108_STAT_TXBYTES
,
512 TSI108_STAT_CARRY2_TXBYTES
,
513 TSI108_STAT_TXBYTES_CARRY
, &data
->stats
.tx_bytes
);
515 data
->tmpstats
.multicast
=
516 tsi108_read_stat(data
, TSI108_STAT_RXMCAST
,
517 TSI108_STAT_CARRY1_RXMCAST
,
518 TSI108_STAT_RXMCAST_CARRY
, &data
->stats
.multicast
);
520 excol
= tsi108_read_stat(data
, TSI108_STAT_TXEXCOL
,
521 TSI108_STAT_CARRY2_TXEXCOL
,
522 TSI108_STAT_TXEXCOL_CARRY
,
523 &data
->tx_coll_abort
);
525 data
->tmpstats
.collisions
=
526 tsi108_read_stat(data
, TSI108_STAT_TXTCOL
,
527 TSI108_STAT_CARRY2_TXTCOL
,
528 TSI108_STAT_TXTCOL_CARRY
, &data
->stats
.collisions
);
530 data
->tmpstats
.collisions
+= excol
;
532 data
->tmpstats
.rx_length_errors
=
533 tsi108_read_stat(data
, TSI108_STAT_RXLENGTH
,
534 TSI108_STAT_CARRY1_RXLENGTH
,
535 TSI108_STAT_RXLENGTH_CARRY
,
536 &data
->stats
.rx_length_errors
);
538 data
->tmpstats
.rx_length_errors
+=
539 tsi108_read_stat(data
, TSI108_STAT_RXRUNT
,
540 TSI108_STAT_CARRY1_RXRUNT
,
541 TSI108_STAT_RXRUNT_CARRY
, &data
->rx_underruns
);
543 data
->tmpstats
.rx_length_errors
+=
544 tsi108_read_stat(data
, TSI108_STAT_RXJUMBO
,
545 TSI108_STAT_CARRY1_RXJUMBO
,
546 TSI108_STAT_RXJUMBO_CARRY
, &data
->rx_overruns
);
548 data
->tmpstats
.rx_frame_errors
=
549 tsi108_read_stat(data
, TSI108_STAT_RXALIGN
,
550 TSI108_STAT_CARRY1_RXALIGN
,
551 TSI108_STAT_RXALIGN_CARRY
,
552 &data
->stats
.rx_frame_errors
);
554 data
->tmpstats
.rx_frame_errors
+=
555 tsi108_read_stat(data
, TSI108_STAT_RXFCS
,
556 TSI108_STAT_CARRY1_RXFCS
, TSI108_STAT_RXFCS_CARRY
,
559 data
->tmpstats
.rx_frame_errors
+=
560 tsi108_read_stat(data
, TSI108_STAT_RXFRAG
,
561 TSI108_STAT_CARRY1_RXFRAG
,
562 TSI108_STAT_RXFRAG_CARRY
, &data
->rx_short_fcs
);
564 data
->tmpstats
.rx_missed_errors
=
565 tsi108_read_stat(data
, TSI108_STAT_RXDROP
,
566 TSI108_STAT_CARRY1_RXDROP
,
567 TSI108_STAT_RXDROP_CARRY
,
568 &data
->stats
.rx_missed_errors
);
570 /* These three are maintained by software. */
571 data
->tmpstats
.rx_fifo_errors
= data
->stats
.rx_fifo_errors
;
572 data
->tmpstats
.rx_crc_errors
= data
->stats
.rx_crc_errors
;
574 data
->tmpstats
.tx_aborted_errors
=
575 tsi108_read_stat(data
, TSI108_STAT_TXEXDEF
,
576 TSI108_STAT_CARRY2_TXEXDEF
,
577 TSI108_STAT_TXEXDEF_CARRY
,
578 &data
->stats
.tx_aborted_errors
);
580 data
->tmpstats
.tx_aborted_errors
+=
581 tsi108_read_stat(data
, TSI108_STAT_TXPAUSEDROP
,
582 TSI108_STAT_CARRY2_TXPAUSE
,
583 TSI108_STAT_TXPAUSEDROP_CARRY
,
584 &data
->tx_pause_drop
);
586 data
->tmpstats
.tx_aborted_errors
+= excol
;
588 data
->tmpstats
.tx_errors
= data
->tmpstats
.tx_aborted_errors
;
589 data
->tmpstats
.rx_errors
= data
->tmpstats
.rx_length_errors
+
590 data
->tmpstats
.rx_crc_errors
+
591 data
->tmpstats
.rx_frame_errors
+
592 data
->tmpstats
.rx_fifo_errors
+ data
->tmpstats
.rx_missed_errors
;
594 spin_unlock_irq(&data
->misclock
);
595 return &data
->tmpstats
;
598 static void tsi108_restart_rx(struct tsi108_prv_data
* data
, struct net_device
*dev
)
600 TSI_WRITE(TSI108_EC_RXQ_PTRHIGH
,
601 TSI108_EC_RXQ_PTRHIGH_VALID
);
603 TSI_WRITE(TSI108_EC_RXCTRL
, TSI108_EC_RXCTRL_GO
604 | TSI108_EC_RXCTRL_QUEUE0
);
607 static void tsi108_restart_tx(struct tsi108_prv_data
* data
)
609 TSI_WRITE(TSI108_EC_TXQ_PTRHIGH
,
610 TSI108_EC_TXQ_PTRHIGH_VALID
);
612 TSI_WRITE(TSI108_EC_TXCTRL
, TSI108_EC_TXCTRL_IDLEINT
|
613 TSI108_EC_TXCTRL_GO
| TSI108_EC_TXCTRL_QUEUE0
);
616 /* txlock must be held by caller, with IRQs disabled, and
617 * with permission to re-enable them when the lock is dropped.
619 static void tsi108_complete_tx(struct net_device
*dev
)
621 struct tsi108_prv_data
*data
= netdev_priv(dev
);
626 while (!data
->txfree
|| data
->txhead
!= data
->txtail
) {
629 if (data
->txring
[tx
].misc
& TSI108_TX_OWN
)
632 skb
= data
->txskbs
[tx
];
634 if (!(data
->txring
[tx
].misc
& TSI108_TX_OK
))
635 printk("%s: bad tx packet, misc %x\n",
636 dev
->name
, data
->txring
[tx
].misc
);
638 data
->txtail
= (data
->txtail
+ 1) % TSI108_TXRING_LEN
;
641 if (data
->txring
[tx
].misc
& TSI108_TX_EOF
) {
642 dev_kfree_skb_any(skb
);
648 if (is_valid_ether_addr(dev
->dev_addr
) && data
->link_up
)
649 netif_wake_queue(dev
);
653 static int tsi108_send_packet(struct sk_buff
* skb
, struct net_device
*dev
)
655 struct tsi108_prv_data
*data
= netdev_priv(dev
);
656 int frags
= skb_shinfo(skb
)->nr_frags
+ 1;
659 if (!data
->phy_ok
&& net_ratelimit())
660 printk(KERN_ERR
"%s: Transmit while PHY is down!\n", dev
->name
);
662 if (!data
->link_up
) {
663 printk(KERN_ERR
"%s: Transmit while link is down!\n",
665 netif_stop_queue(dev
);
666 return NETDEV_TX_BUSY
;
669 if (data
->txfree
< MAX_SKB_FRAGS
+ 1) {
670 netif_stop_queue(dev
);
673 printk(KERN_ERR
"%s: Transmit with full tx ring!\n",
675 return NETDEV_TX_BUSY
;
678 if (data
->txfree
- frags
< MAX_SKB_FRAGS
+ 1) {
679 netif_stop_queue(dev
);
682 spin_lock_irq(&data
->txlock
);
684 for (i
= 0; i
< frags
; i
++) {
686 int tx
= data
->txhead
;
688 /* This is done to mark every TSI108_TX_INT_FREQ tx buffers with
689 * the interrupt bit. TX descriptor-complete interrupts are
690 * enabled when the queue fills up, and masked when there is
691 * still free space. This way, when saturating the outbound
692 * link, the tx interrupts are kept to a reasonable level.
693 * When the queue is not full, reclamation of skbs still occurs
694 * as new packets are transmitted, or on a queue-empty
698 if ((tx
% TSI108_TX_INT_FREQ
== 0) &&
699 ((TSI108_TXRING_LEN
- data
->txfree
) >= TSI108_TX_INT_FREQ
))
700 misc
= TSI108_TX_INT
;
702 data
->txskbs
[tx
] = skb
;
705 data
->txring
[tx
].buf0
= dma_map_single(NULL
, skb
->data
,
706 skb
->len
- skb
->data_len
, DMA_TO_DEVICE
);
707 data
->txring
[tx
].len
= skb
->len
- skb
->data_len
;
708 misc
|= TSI108_TX_SOF
;
710 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
- 1];
712 data
->txring
[tx
].buf0
=
713 dma_map_page(NULL
, frag
->page
, frag
->page_offset
,
714 frag
->size
, DMA_TO_DEVICE
);
715 data
->txring
[tx
].len
= frag
->size
;
719 misc
|= TSI108_TX_EOF
;
721 if (netif_msg_pktdata(data
)) {
723 printk("%s: Tx Frame contents (%d)\n", dev
->name
,
725 for (i
= 0; i
< skb
->len
; i
++)
726 printk(" %2.2x", skb
->data
[i
]);
729 data
->txring
[tx
].misc
= misc
| TSI108_TX_OWN
;
731 data
->txhead
= (data
->txhead
+ 1) % TSI108_TXRING_LEN
;
735 tsi108_complete_tx(dev
);
737 /* This must be done after the check for completed tx descriptors,
738 * so that the tail pointer is correct.
741 if (!(TSI_READ(TSI108_EC_TXSTAT
) & TSI108_EC_TXSTAT_QUEUE0
))
742 tsi108_restart_tx(data
);
744 spin_unlock_irq(&data
->txlock
);
748 static int tsi108_complete_rx(struct net_device
*dev
, int budget
)
750 struct tsi108_prv_data
*data
= netdev_priv(dev
);
753 while (data
->rxfree
&& done
!= budget
) {
754 int rx
= data
->rxtail
;
757 if (data
->rxring
[rx
].misc
& TSI108_RX_OWN
)
760 skb
= data
->rxskbs
[rx
];
761 data
->rxtail
= (data
->rxtail
+ 1) % TSI108_RXRING_LEN
;
765 if (data
->rxring
[rx
].misc
& TSI108_RX_BAD
) {
766 spin_lock_irq(&data
->misclock
);
768 if (data
->rxring
[rx
].misc
& TSI108_RX_CRC
)
769 data
->stats
.rx_crc_errors
++;
770 if (data
->rxring
[rx
].misc
& TSI108_RX_OVER
)
771 data
->stats
.rx_fifo_errors
++;
773 spin_unlock_irq(&data
->misclock
);
775 dev_kfree_skb_any(skb
);
778 if (netif_msg_pktdata(data
)) {
780 printk("%s: Rx Frame contents (%d)\n",
781 dev
->name
, data
->rxring
[rx
].len
);
782 for (i
= 0; i
< data
->rxring
[rx
].len
; i
++)
783 printk(" %2.2x", skb
->data
[i
]);
787 skb_put(skb
, data
->rxring
[rx
].len
);
788 skb
->protocol
= eth_type_trans(skb
, dev
);
789 netif_receive_skb(skb
);
790 dev
->last_rx
= jiffies
;
796 static int tsi108_refill_rx(struct net_device
*dev
, int budget
)
798 struct tsi108_prv_data
*data
= netdev_priv(dev
);
801 while (data
->rxfree
!= TSI108_RXRING_LEN
&& done
!= budget
) {
802 int rx
= data
->rxhead
;
805 data
->rxskbs
[rx
] = skb
= dev_alloc_skb(TSI108_RXBUF_SIZE
+ 2);
809 skb_reserve(skb
, 2); /* Align the data on a 4-byte boundary. */
811 data
->rxring
[rx
].buf0
= dma_map_single(NULL
, skb
->data
,
815 /* Sometimes the hardware sets blen to zero after packet
816 * reception, even though the manual says that it's only ever
817 * modified by the driver.
820 data
->rxring
[rx
].blen
= TSI108_RX_SKB_SIZE
;
821 data
->rxring
[rx
].misc
= TSI108_RX_OWN
| TSI108_RX_INT
;
823 data
->rxhead
= (data
->rxhead
+ 1) % TSI108_RXRING_LEN
;
828 if (done
!= 0 && !(TSI_READ(TSI108_EC_RXSTAT
) &
829 TSI108_EC_RXSTAT_QUEUE0
))
830 tsi108_restart_rx(data
, dev
);
835 static int tsi108_poll(struct napi_struct
*napi
, int budget
)
837 struct tsi108_prv_data
*data
= container_of(napi
, struct tsi108_prv_data
, napi
);
838 struct net_device
*dev
= data
->dev
;
839 u32 estat
= TSI_READ(TSI108_EC_RXESTAT
);
840 u32 intstat
= TSI_READ(TSI108_EC_INTSTAT
);
841 int num_received
= 0, num_filled
= 0;
843 intstat
&= TSI108_INT_RXQUEUE0
| TSI108_INT_RXTHRESH
|
844 TSI108_INT_RXOVERRUN
| TSI108_INT_RXERROR
| TSI108_INT_RXWAIT
;
846 TSI_WRITE(TSI108_EC_RXESTAT
, estat
);
847 TSI_WRITE(TSI108_EC_INTSTAT
, intstat
);
849 if (data
->rxpending
|| (estat
& TSI108_EC_RXESTAT_Q0_DESCINT
))
850 num_received
= tsi108_complete_rx(dev
, budget
);
852 /* This should normally fill no more slots than the number of
853 * packets received in tsi108_complete_rx(). The exception
854 * is when we previously ran out of memory for RX SKBs. In that
855 * case, it's helpful to obey the budget, not only so that the
856 * CPU isn't hogged, but so that memory (which may still be low)
857 * is not hogged by one device.
859 * A work unit is considered to be two SKBs to allow us to catch
860 * up when the ring has shrunk due to out-of-memory but we're
861 * still removing the full budget's worth of packets each time.
864 if (data
->rxfree
< TSI108_RXRING_LEN
)
865 num_filled
= tsi108_refill_rx(dev
, budget
* 2);
867 if (intstat
& TSI108_INT_RXERROR
) {
868 u32 err
= TSI_READ(TSI108_EC_RXERR
);
869 TSI_WRITE(TSI108_EC_RXERR
, err
);
873 printk(KERN_DEBUG
"%s: RX error %x\n",
876 if (!(TSI_READ(TSI108_EC_RXSTAT
) &
877 TSI108_EC_RXSTAT_QUEUE0
))
878 tsi108_restart_rx(data
, dev
);
882 if (intstat
& TSI108_INT_RXOVERRUN
) {
883 spin_lock_irq(&data
->misclock
);
884 data
->stats
.rx_fifo_errors
++;
885 spin_unlock_irq(&data
->misclock
);
888 if (num_received
< budget
) {
890 netif_rx_complete(dev
, napi
);
892 TSI_WRITE(TSI108_EC_INTMASK
,
893 TSI_READ(TSI108_EC_INTMASK
)
894 & ~(TSI108_INT_RXQUEUE0
895 | TSI108_INT_RXTHRESH
|
896 TSI108_INT_RXOVERRUN
|
906 static void tsi108_rx_int(struct net_device
*dev
)
908 struct tsi108_prv_data
*data
= netdev_priv(dev
);
910 /* A race could cause dev to already be scheduled, so it's not an
911 * error if that happens (and interrupts shouldn't be re-masked,
912 * because that can cause harmful races, if poll has already
913 * unmasked them but not cleared LINK_STATE_SCHED).
915 * This can happen if this code races with tsi108_poll(), which masks
916 * the interrupts after tsi108_irq_one() read the mask, but before
917 * netif_rx_schedule is called. It could also happen due to calls
918 * from tsi108_check_rxring().
921 if (netif_rx_schedule_prep(dev
, &data
->napi
)) {
922 /* Mask, rather than ack, the receive interrupts. The ack
923 * will happen in tsi108_poll().
926 TSI_WRITE(TSI108_EC_INTMASK
,
927 TSI_READ(TSI108_EC_INTMASK
) |
929 | TSI108_INT_RXTHRESH
|
930 TSI108_INT_RXOVERRUN
| TSI108_INT_RXERROR
|
932 __netif_rx_schedule(dev
, &data
->napi
);
934 if (!netif_running(dev
)) {
935 /* This can happen if an interrupt occurs while the
936 * interface is being brought down, as the START
937 * bit is cleared before the stop function is called.
939 * In this case, the interrupts must be masked, or
940 * they will continue indefinitely.
942 * There's a race here if the interface is brought down
943 * and then up in rapid succession, as the device could
944 * be made running after the above check and before
945 * the masking below. This will only happen if the IRQ
946 * thread has a lower priority than the task brining
947 * up the interface. Fixing this race would likely
948 * require changes in generic code.
951 TSI_WRITE(TSI108_EC_INTMASK
,
953 (TSI108_EC_INTMASK
) |
954 TSI108_INT_RXQUEUE0
|
955 TSI108_INT_RXTHRESH
|
956 TSI108_INT_RXOVERRUN
|
963 /* If the RX ring has run out of memory, try periodically
964 * to allocate some more, as otherwise poll would never
965 * get called (apart from the initial end-of-queue condition).
967 * This is called once per second (by default) from the thread.
970 static void tsi108_check_rxring(struct net_device
*dev
)
972 struct tsi108_prv_data
*data
= netdev_priv(dev
);
974 /* A poll is scheduled, as opposed to caling tsi108_refill_rx
975 * directly, so as to keep the receive path single-threaded
976 * (and thus not needing a lock).
979 if (netif_running(dev
) && data
->rxfree
< TSI108_RXRING_LEN
/ 4)
983 static void tsi108_tx_int(struct net_device
*dev
)
985 struct tsi108_prv_data
*data
= netdev_priv(dev
);
986 u32 estat
= TSI_READ(TSI108_EC_TXESTAT
);
988 TSI_WRITE(TSI108_EC_TXESTAT
, estat
);
989 TSI_WRITE(TSI108_EC_INTSTAT
, TSI108_INT_TXQUEUE0
|
990 TSI108_INT_TXIDLE
| TSI108_INT_TXERROR
);
991 if (estat
& TSI108_EC_TXESTAT_Q0_ERR
) {
992 u32 err
= TSI_READ(TSI108_EC_TXERR
);
993 TSI_WRITE(TSI108_EC_TXERR
, err
);
995 if (err
&& net_ratelimit())
996 printk(KERN_ERR
"%s: TX error %x\n", dev
->name
, err
);
999 if (estat
& (TSI108_EC_TXESTAT_Q0_DESCINT
| TSI108_EC_TXESTAT_Q0_EOQ
)) {
1000 spin_lock(&data
->txlock
);
1001 tsi108_complete_tx(dev
);
1002 spin_unlock(&data
->txlock
);
1007 static irqreturn_t
tsi108_irq(int irq
, void *dev_id
)
1009 struct net_device
*dev
= dev_id
;
1010 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1011 u32 stat
= TSI_READ(TSI108_EC_INTSTAT
);
1013 if (!(stat
& TSI108_INT_ANY
))
1014 return IRQ_NONE
; /* Not our interrupt */
1016 stat
&= ~TSI_READ(TSI108_EC_INTMASK
);
1018 if (stat
& (TSI108_INT_TXQUEUE0
| TSI108_INT_TXIDLE
|
1019 TSI108_INT_TXERROR
))
1021 if (stat
& (TSI108_INT_RXQUEUE0
| TSI108_INT_RXTHRESH
|
1022 TSI108_INT_RXWAIT
| TSI108_INT_RXOVERRUN
|
1023 TSI108_INT_RXERROR
))
1026 if (stat
& TSI108_INT_SFN
) {
1027 if (net_ratelimit())
1028 printk(KERN_DEBUG
"%s: SFN error\n", dev
->name
);
1029 TSI_WRITE(TSI108_EC_INTSTAT
, TSI108_INT_SFN
);
1032 if (stat
& TSI108_INT_STATCARRY
) {
1033 tsi108_stat_carry(dev
);
1034 TSI_WRITE(TSI108_EC_INTSTAT
, TSI108_INT_STATCARRY
);
1040 static void tsi108_stop_ethernet(struct net_device
*dev
)
1042 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1044 /* Disable all TX and RX queues ... */
1045 TSI_WRITE(TSI108_EC_TXCTRL
, 0);
1046 TSI_WRITE(TSI108_EC_RXCTRL
, 0);
1048 /* ...and wait for them to become idle */
1050 if(!(TSI_READ(TSI108_EC_TXSTAT
) & TSI108_EC_TXSTAT_ACTIVE
))
1056 if(!(TSI_READ(TSI108_EC_RXSTAT
) & TSI108_EC_RXSTAT_ACTIVE
))
1060 printk(KERN_ERR
"%s function time out \n", __FUNCTION__
);
1063 static void tsi108_reset_ether(struct tsi108_prv_data
* data
)
1065 TSI_WRITE(TSI108_MAC_CFG1
, TSI108_MAC_CFG1_SOFTRST
);
1067 TSI_WRITE(TSI108_MAC_CFG1
, 0);
1069 TSI_WRITE(TSI108_EC_PORTCTRL
, TSI108_EC_PORTCTRL_STATRST
);
1071 TSI_WRITE(TSI108_EC_PORTCTRL
,
1072 TSI_READ(TSI108_EC_PORTCTRL
) &
1073 ~TSI108_EC_PORTCTRL_STATRST
);
1075 TSI_WRITE(TSI108_EC_TXCFG
, TSI108_EC_TXCFG_RST
);
1077 TSI_WRITE(TSI108_EC_TXCFG
,
1078 TSI_READ(TSI108_EC_TXCFG
) &
1079 ~TSI108_EC_TXCFG_RST
);
1081 TSI_WRITE(TSI108_EC_RXCFG
, TSI108_EC_RXCFG_RST
);
1083 TSI_WRITE(TSI108_EC_RXCFG
,
1084 TSI_READ(TSI108_EC_RXCFG
) &
1085 ~TSI108_EC_RXCFG_RST
);
1087 TSI_WRITE(TSI108_MAC_MII_MGMT_CFG
,
1088 TSI_READ(TSI108_MAC_MII_MGMT_CFG
) |
1089 TSI108_MAC_MII_MGMT_RST
);
1091 TSI_WRITE(TSI108_MAC_MII_MGMT_CFG
,
1092 (TSI_READ(TSI108_MAC_MII_MGMT_CFG
) &
1093 ~(TSI108_MAC_MII_MGMT_RST
|
1094 TSI108_MAC_MII_MGMT_CLK
)) | 0x07);
1097 static int tsi108_get_mac(struct net_device
*dev
)
1099 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1100 u32 word1
= TSI_READ(TSI108_MAC_ADDR1
);
1101 u32 word2
= TSI_READ(TSI108_MAC_ADDR2
);
1103 /* Note that the octets are reversed from what the manual says,
1104 * producing an even weirder ordering...
1106 if (word2
== 0 && word1
== 0) {
1107 dev
->dev_addr
[0] = 0x00;
1108 dev
->dev_addr
[1] = 0x06;
1109 dev
->dev_addr
[2] = 0xd2;
1110 dev
->dev_addr
[3] = 0x00;
1111 dev
->dev_addr
[4] = 0x00;
1112 if (0x8 == data
->phy
)
1113 dev
->dev_addr
[5] = 0x01;
1115 dev
->dev_addr
[5] = 0x02;
1117 word2
= (dev
->dev_addr
[0] << 16) | (dev
->dev_addr
[1] << 24);
1119 word1
= (dev
->dev_addr
[2] << 0) | (dev
->dev_addr
[3] << 8) |
1120 (dev
->dev_addr
[4] << 16) | (dev
->dev_addr
[5] << 24);
1122 TSI_WRITE(TSI108_MAC_ADDR1
, word1
);
1123 TSI_WRITE(TSI108_MAC_ADDR2
, word2
);
1125 dev
->dev_addr
[0] = (word2
>> 16) & 0xff;
1126 dev
->dev_addr
[1] = (word2
>> 24) & 0xff;
1127 dev
->dev_addr
[2] = (word1
>> 0) & 0xff;
1128 dev
->dev_addr
[3] = (word1
>> 8) & 0xff;
1129 dev
->dev_addr
[4] = (word1
>> 16) & 0xff;
1130 dev
->dev_addr
[5] = (word1
>> 24) & 0xff;
1133 if (!is_valid_ether_addr(dev
->dev_addr
)) {
1134 printk("KERN_ERR: word1: %08x, word2: %08x\n", word1
, word2
);
1141 static int tsi108_set_mac(struct net_device
*dev
, void *addr
)
1143 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1147 if (!is_valid_ether_addr(addr
))
1150 for (i
= 0; i
< 6; i
++)
1151 /* +2 is for the offset of the HW addr type */
1152 dev
->dev_addr
[i
] = ((unsigned char *)addr
)[i
+ 2];
1154 word2
= (dev
->dev_addr
[0] << 16) | (dev
->dev_addr
[1] << 24);
1156 word1
= (dev
->dev_addr
[2] << 0) | (dev
->dev_addr
[3] << 8) |
1157 (dev
->dev_addr
[4] << 16) | (dev
->dev_addr
[5] << 24);
1159 spin_lock_irq(&data
->misclock
);
1160 TSI_WRITE(TSI108_MAC_ADDR1
, word1
);
1161 TSI_WRITE(TSI108_MAC_ADDR2
, word2
);
1162 spin_lock(&data
->txlock
);
1164 if (data
->txfree
&& data
->link_up
)
1165 netif_wake_queue(dev
);
1167 spin_unlock(&data
->txlock
);
1168 spin_unlock_irq(&data
->misclock
);
1172 /* Protected by dev->xmit_lock. */
1173 static void tsi108_set_rx_mode(struct net_device
*dev
)
1175 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1176 u32 rxcfg
= TSI_READ(TSI108_EC_RXCFG
);
1178 if (dev
->flags
& IFF_PROMISC
) {
1179 rxcfg
&= ~(TSI108_EC_RXCFG_UC_HASH
| TSI108_EC_RXCFG_MC_HASH
);
1180 rxcfg
|= TSI108_EC_RXCFG_UFE
| TSI108_EC_RXCFG_MFE
;
1184 rxcfg
&= ~(TSI108_EC_RXCFG_UFE
| TSI108_EC_RXCFG_MFE
);
1186 if (dev
->flags
& IFF_ALLMULTI
|| dev
->mc_count
) {
1188 struct dev_mc_list
*mc
= dev
->mc_list
;
1189 rxcfg
|= TSI108_EC_RXCFG_MFE
| TSI108_EC_RXCFG_MC_HASH
;
1191 memset(data
->mc_hash
, 0, sizeof(data
->mc_hash
));
1196 if (mc
->dmi_addrlen
== 6) {
1197 crc
= ether_crc(6, mc
->dmi_addr
);
1200 __set_bit(hash
, &data
->mc_hash
[0]);
1203 "%s: got multicast address of length %d "
1204 "instead of 6.\n", dev
->name
,
1211 TSI_WRITE(TSI108_EC_HASHADDR
,
1212 TSI108_EC_HASHADDR_AUTOINC
|
1213 TSI108_EC_HASHADDR_MCAST
);
1215 for (i
= 0; i
< 16; i
++) {
1216 /* The manual says that the hardware may drop
1217 * back-to-back writes to the data register.
1220 TSI_WRITE(TSI108_EC_HASHDATA
,
1226 TSI_WRITE(TSI108_EC_RXCFG
, rxcfg
);
1229 static void tsi108_init_phy(struct net_device
*dev
)
1231 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1234 unsigned long flags
;
1236 spin_lock_irqsave(&phy_lock
, flags
);
1238 tsi108_write_mii(data
, MII_BMCR
, BMCR_RESET
);
1240 if(!(tsi108_read_mii(data
, MII_BMCR
) & BMCR_RESET
))
1245 printk(KERN_ERR
"%s function time out \n", __FUNCTION__
);
1247 if (data
->phy_type
== TSI108_PHY_BCM54XX
) {
1248 tsi108_write_mii(data
, 0x09, 0x0300);
1249 tsi108_write_mii(data
, 0x10, 0x1020);
1250 tsi108_write_mii(data
, 0x1c, 0x8c00);
1253 tsi108_write_mii(data
,
1255 BMCR_ANENABLE
| BMCR_ANRESTART
);
1256 while (tsi108_read_mii(data
, MII_BMCR
) & BMCR_ANRESTART
)
1259 /* Set G/MII mode and receive clock select in TBI control #2. The
1260 * second port won't work if this isn't done, even though we don't
1264 tsi108_write_tbi(data
, 0x11, 0x30);
1266 /* FIXME: It seems to take more than 2 back-to-back reads to the
1267 * PHY_STAT register before the link up status bit is set.
1272 while (!((phyval
= tsi108_read_mii(data
, MII_BMSR
)) &
1274 if (i
++ > (MII_READ_DELAY
/ 10)) {
1278 spin_unlock_irqrestore(&phy_lock
, flags
);
1280 spin_lock_irqsave(&phy_lock
, flags
);
1283 data
->mii_if
.supports_gmii
= mii_check_gmii_support(&data
->mii_if
);
1284 printk(KERN_DEBUG
"PHY_STAT reg contains %08x\n", phyval
);
1286 data
->init_media
= 1;
1287 spin_unlock_irqrestore(&phy_lock
, flags
);
1290 static void tsi108_kill_phy(struct net_device
*dev
)
1292 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1293 unsigned long flags
;
1295 spin_lock_irqsave(&phy_lock
, flags
);
1296 tsi108_write_mii(data
, MII_BMCR
, BMCR_PDOWN
);
1298 spin_unlock_irqrestore(&phy_lock
, flags
);
1301 static int tsi108_open(struct net_device
*dev
)
1304 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1305 unsigned int rxring_size
= TSI108_RXRING_LEN
* sizeof(rx_desc
);
1306 unsigned int txring_size
= TSI108_TXRING_LEN
* sizeof(tx_desc
);
1308 i
= request_irq(data
->irq_num
, tsi108_irq
, 0, dev
->name
, dev
);
1310 printk(KERN_ERR
"tsi108_eth%d: Could not allocate IRQ%d.\n",
1311 data
->id
, data
->irq_num
);
1314 dev
->irq
= data
->irq_num
;
1316 "tsi108_open : Port %d Assigned IRQ %d to %s\n",
1317 data
->id
, dev
->irq
, dev
->name
);
1320 data
->rxring
= dma_alloc_coherent(NULL
, rxring_size
,
1321 &data
->rxdma
, GFP_KERNEL
);
1323 if (!data
->rxring
) {
1325 "TSI108_ETH: failed to allocate memory for rxring!\n");
1328 memset(data
->rxring
, 0, rxring_size
);
1331 data
->txring
= dma_alloc_coherent(NULL
, txring_size
,
1332 &data
->txdma
, GFP_KERNEL
);
1334 if (!data
->txring
) {
1336 "TSI108_ETH: failed to allocate memory for txring!\n");
1337 pci_free_consistent(0, rxring_size
, data
->rxring
, data
->rxdma
);
1340 memset(data
->txring
, 0, txring_size
);
1343 for (i
= 0; i
< TSI108_RXRING_LEN
; i
++) {
1344 data
->rxring
[i
].next0
= data
->rxdma
+ (i
+ 1) * sizeof(rx_desc
);
1345 data
->rxring
[i
].blen
= TSI108_RXBUF_SIZE
;
1346 data
->rxring
[i
].vlan
= 0;
1349 data
->rxring
[TSI108_RXRING_LEN
- 1].next0
= data
->rxdma
;
1354 for (i
= 0; i
< TSI108_RXRING_LEN
; i
++) {
1355 struct sk_buff
*skb
= dev_alloc_skb(TSI108_RXBUF_SIZE
+ NET_IP_ALIGN
);
1358 /* Bah. No memory for now, but maybe we'll get
1360 * For now, we'll live with the smaller ring.
1363 "%s: Could only allocate %d receive skb(s).\n",
1369 data
->rxskbs
[i
] = skb
;
1370 /* Align the payload on a 4-byte boundary */
1371 skb_reserve(skb
, 2);
1372 data
->rxskbs
[i
] = skb
;
1373 data
->rxring
[i
].buf0
= virt_to_phys(data
->rxskbs
[i
]->data
);
1374 data
->rxring
[i
].misc
= TSI108_RX_OWN
| TSI108_RX_INT
;
1378 TSI_WRITE(TSI108_EC_RXQ_PTRLOW
, data
->rxdma
);
1380 for (i
= 0; i
< TSI108_TXRING_LEN
; i
++) {
1381 data
->txring
[i
].next0
= data
->txdma
+ (i
+ 1) * sizeof(tx_desc
);
1382 data
->txring
[i
].misc
= 0;
1385 data
->txring
[TSI108_TXRING_LEN
- 1].next0
= data
->txdma
;
1388 data
->txfree
= TSI108_TXRING_LEN
;
1389 TSI_WRITE(TSI108_EC_TXQ_PTRLOW
, data
->txdma
);
1390 tsi108_init_phy(dev
);
1392 napi_enable(&data
->napi
);
1394 setup_timer(&data
->timer
, tsi108_timed_checker
, (unsigned long)dev
);
1395 mod_timer(&data
->timer
, jiffies
+ 1);
1397 tsi108_restart_rx(data
, dev
);
1399 TSI_WRITE(TSI108_EC_INTSTAT
, ~0);
1401 TSI_WRITE(TSI108_EC_INTMASK
,
1402 ~(TSI108_INT_TXQUEUE0
| TSI108_INT_RXERROR
|
1403 TSI108_INT_RXTHRESH
| TSI108_INT_RXQUEUE0
|
1404 TSI108_INT_RXOVERRUN
| TSI108_INT_RXWAIT
|
1405 TSI108_INT_SFN
| TSI108_INT_STATCARRY
));
1407 TSI_WRITE(TSI108_MAC_CFG1
,
1408 TSI108_MAC_CFG1_RXEN
| TSI108_MAC_CFG1_TXEN
);
1409 netif_start_queue(dev
);
1413 static int tsi108_close(struct net_device
*dev
)
1415 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1417 netif_stop_queue(dev
);
1418 napi_disable(&data
->napi
);
1420 del_timer_sync(&data
->timer
);
1422 tsi108_stop_ethernet(dev
);
1423 tsi108_kill_phy(dev
);
1424 TSI_WRITE(TSI108_EC_INTMASK
, ~0);
1425 TSI_WRITE(TSI108_MAC_CFG1
, 0);
1427 /* Check for any pending TX packets, and drop them. */
1429 while (!data
->txfree
|| data
->txhead
!= data
->txtail
) {
1430 int tx
= data
->txtail
;
1431 struct sk_buff
*skb
;
1432 skb
= data
->txskbs
[tx
];
1433 data
->txtail
= (data
->txtail
+ 1) % TSI108_TXRING_LEN
;
1438 synchronize_irq(data
->irq_num
);
1439 free_irq(data
->irq_num
, dev
);
1441 /* Discard the RX ring. */
1443 while (data
->rxfree
) {
1444 int rx
= data
->rxtail
;
1445 struct sk_buff
*skb
;
1447 skb
= data
->rxskbs
[rx
];
1448 data
->rxtail
= (data
->rxtail
+ 1) % TSI108_RXRING_LEN
;
1453 dma_free_coherent(0,
1454 TSI108_RXRING_LEN
* sizeof(rx_desc
),
1455 data
->rxring
, data
->rxdma
);
1456 dma_free_coherent(0,
1457 TSI108_TXRING_LEN
* sizeof(tx_desc
),
1458 data
->txring
, data
->txdma
);
1463 static void tsi108_init_mac(struct net_device
*dev
)
1465 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1467 TSI_WRITE(TSI108_MAC_CFG2
, TSI108_MAC_CFG2_DFLT_PREAMBLE
|
1468 TSI108_MAC_CFG2_PADCRC
);
1470 TSI_WRITE(TSI108_EC_TXTHRESH
,
1471 (192 << TSI108_EC_TXTHRESH_STARTFILL
) |
1472 (192 << TSI108_EC_TXTHRESH_STOPFILL
));
1474 TSI_WRITE(TSI108_STAT_CARRYMASK1
,
1475 ~(TSI108_STAT_CARRY1_RXBYTES
|
1476 TSI108_STAT_CARRY1_RXPKTS
|
1477 TSI108_STAT_CARRY1_RXFCS
|
1478 TSI108_STAT_CARRY1_RXMCAST
|
1479 TSI108_STAT_CARRY1_RXALIGN
|
1480 TSI108_STAT_CARRY1_RXLENGTH
|
1481 TSI108_STAT_CARRY1_RXRUNT
|
1482 TSI108_STAT_CARRY1_RXJUMBO
|
1483 TSI108_STAT_CARRY1_RXFRAG
|
1484 TSI108_STAT_CARRY1_RXJABBER
|
1485 TSI108_STAT_CARRY1_RXDROP
));
1487 TSI_WRITE(TSI108_STAT_CARRYMASK2
,
1488 ~(TSI108_STAT_CARRY2_TXBYTES
|
1489 TSI108_STAT_CARRY2_TXPKTS
|
1490 TSI108_STAT_CARRY2_TXEXDEF
|
1491 TSI108_STAT_CARRY2_TXEXCOL
|
1492 TSI108_STAT_CARRY2_TXTCOL
|
1493 TSI108_STAT_CARRY2_TXPAUSE
));
1495 TSI_WRITE(TSI108_EC_PORTCTRL
, TSI108_EC_PORTCTRL_STATEN
);
1496 TSI_WRITE(TSI108_MAC_CFG1
, 0);
1498 TSI_WRITE(TSI108_EC_RXCFG
,
1499 TSI108_EC_RXCFG_SE
| TSI108_EC_RXCFG_BFE
);
1501 TSI_WRITE(TSI108_EC_TXQ_CFG
, TSI108_EC_TXQ_CFG_DESC_INT
|
1502 TSI108_EC_TXQ_CFG_EOQ_OWN_INT
|
1503 TSI108_EC_TXQ_CFG_WSWP
| (TSI108_PBM_PORT
<<
1504 TSI108_EC_TXQ_CFG_SFNPORT
));
1506 TSI_WRITE(TSI108_EC_RXQ_CFG
, TSI108_EC_RXQ_CFG_DESC_INT
|
1507 TSI108_EC_RXQ_CFG_EOQ_OWN_INT
|
1508 TSI108_EC_RXQ_CFG_WSWP
| (TSI108_PBM_PORT
<<
1509 TSI108_EC_RXQ_CFG_SFNPORT
));
1511 TSI_WRITE(TSI108_EC_TXQ_BUFCFG
,
1512 TSI108_EC_TXQ_BUFCFG_BURST256
|
1513 TSI108_EC_TXQ_BUFCFG_BSWP
| (TSI108_PBM_PORT
<<
1514 TSI108_EC_TXQ_BUFCFG_SFNPORT
));
1516 TSI_WRITE(TSI108_EC_RXQ_BUFCFG
,
1517 TSI108_EC_RXQ_BUFCFG_BURST256
|
1518 TSI108_EC_RXQ_BUFCFG_BSWP
| (TSI108_PBM_PORT
<<
1519 TSI108_EC_RXQ_BUFCFG_SFNPORT
));
1521 TSI_WRITE(TSI108_EC_INTMASK
, ~0);
1524 static int tsi108_do_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1526 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1527 return generic_mii_ioctl(&data
->mii_if
, if_mii(rq
), cmd
, NULL
);
1531 tsi108_init_one(struct platform_device
*pdev
)
1533 struct net_device
*dev
= NULL
;
1534 struct tsi108_prv_data
*data
= NULL
;
1537 DECLARE_MAC_BUF(mac
);
1539 einfo
= pdev
->dev
.platform_data
;
1541 if (NULL
== einfo
) {
1542 printk(KERN_ERR
"tsi-eth %d: Missing additional data!\n",
1547 /* Create an ethernet device instance */
1549 dev
= alloc_etherdev(sizeof(struct tsi108_prv_data
));
1551 printk("tsi108_eth: Could not allocate a device structure\n");
1555 printk("tsi108_eth%d: probe...\n", pdev
->id
);
1556 data
= netdev_priv(dev
);
1559 pr_debug("tsi108_eth%d:regs:phyresgs:phy:irq_num=0x%x:0x%x:0x%x:0x%x\n",
1560 pdev
->id
, einfo
->regs
, einfo
->phyregs
,
1561 einfo
->phy
, einfo
->irq_num
);
1563 data
->regs
= ioremap(einfo
->regs
, 0x400);
1564 if (NULL
== data
->regs
) {
1569 data
->phyregs
= ioremap(einfo
->phyregs
, 0x400);
1570 if (NULL
== data
->phyregs
) {
1575 data
->mii_if
.dev
= dev
;
1576 data
->mii_if
.mdio_read
= tsi108_mdio_read
;
1577 data
->mii_if
.mdio_write
= tsi108_mdio_write
;
1578 data
->mii_if
.phy_id
= einfo
->phy
;
1579 data
->mii_if
.phy_id_mask
= 0x1f;
1580 data
->mii_if
.reg_num_mask
= 0x1f;
1582 data
->phy
= einfo
->phy
;
1583 data
->phy_type
= einfo
->phy_type
;
1584 data
->irq_num
= einfo
->irq_num
;
1585 data
->id
= pdev
->id
;
1586 dev
->open
= tsi108_open
;
1587 dev
->stop
= tsi108_close
;
1588 dev
->hard_start_xmit
= tsi108_send_packet
;
1589 dev
->set_mac_address
= tsi108_set_mac
;
1590 dev
->set_multicast_list
= tsi108_set_rx_mode
;
1591 dev
->get_stats
= tsi108_get_stats
;
1592 netif_napi_add(dev
, &data
->napi
, tsi108_poll
, 64);
1593 dev
->do_ioctl
= tsi108_do_ioctl
;
1595 /* Apparently, the Linux networking code won't use scatter-gather
1596 * if the hardware doesn't do checksums. However, it's faster
1597 * to checksum in place and use SG, as (among other reasons)
1598 * the cache won't be dirtied (which then has to be flushed
1599 * before DMA). The checksumming is done by the driver (via
1600 * a new function skb_csum_dev() in net/core/skbuff.c).
1603 dev
->features
= NETIF_F_HIGHDMA
;
1605 spin_lock_init(&data
->txlock
);
1606 spin_lock_init(&data
->misclock
);
1608 tsi108_reset_ether(data
);
1609 tsi108_kill_phy(dev
);
1611 if ((err
= tsi108_get_mac(dev
)) != 0) {
1612 printk(KERN_ERR
"%s: Invalid MAC address. Please correct.\n",
1617 tsi108_init_mac(dev
);
1618 err
= register_netdev(dev
);
1620 printk(KERN_ERR
"%s: Cannot register net device, aborting.\n",
1625 platform_set_drvdata(pdev
, dev
);
1626 printk(KERN_INFO
"%s: Tsi108 Gigabit Ethernet, MAC: %s\n",
1627 dev
->name
, print_mac(mac
, dev
->dev_addr
));
1629 data
->msg_enable
= DEBUG
;
1636 iounmap(data
->regs
);
1637 iounmap(data
->phyregs
);
1644 /* There's no way to either get interrupts from the PHY when
1645 * something changes, or to have the Tsi108 automatically communicate
1646 * with the PHY to reconfigure itself.
1648 * Thus, we have to do it using a timer.
1651 static void tsi108_timed_checker(unsigned long dev_ptr
)
1653 struct net_device
*dev
= (struct net_device
*)dev_ptr
;
1654 struct tsi108_prv_data
*data
= netdev_priv(dev
);
1656 tsi108_check_phy(dev
);
1657 tsi108_check_rxring(dev
);
1658 mod_timer(&data
->timer
, jiffies
+ CHECK_PHY_INTERVAL
);
1661 static int tsi108_ether_init(void)
1664 ret
= platform_driver_register (&tsi_eth_driver
);
1666 printk("tsi108_ether_init: error initializing ethernet "
1673 static int tsi108_ether_remove(struct platform_device
*pdev
)
1675 struct net_device
*dev
= platform_get_drvdata(pdev
);
1676 struct tsi108_prv_data
*priv
= netdev_priv(dev
);
1678 unregister_netdev(dev
);
1679 tsi108_stop_ethernet(dev
);
1680 platform_set_drvdata(pdev
, NULL
);
1681 iounmap(priv
->regs
);
1682 iounmap(priv
->phyregs
);
1687 static void tsi108_ether_exit(void)
1689 platform_driver_unregister(&tsi_eth_driver
);
1692 module_init(tsi108_ether_init
);
1693 module_exit(tsi108_ether_exit
);
1695 MODULE_AUTHOR("Tundra Semiconductor Corporation");
1696 MODULE_DESCRIPTION("Tsi108 Gigabit Ethernet driver");
1697 MODULE_LICENSE("GPL");