2 * New driver for Marvell Yukon chipset and SysKonnect Gigabit
3 * Ethernet adapters. Based on earlier sk98lin, e100 and
4 * FreeBSD if_sk drivers.
6 * This driver intentionally does not support all the features
7 * of the original driver such as link fail-over and link management because
8 * those should be done at higher levels.
10 * Copyright (C) 2004, 2005 Stephen Hemminger <shemminger@osdl.org>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/config.h>
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
31 #include <linux/netdevice.h>
32 #include <linux/etherdevice.h>
33 #include <linux/ethtool.h>
34 #include <linux/pci.h>
35 #include <linux/if_vlan.h>
37 #include <linux/delay.h>
38 #include <linux/crc32.h>
39 #include <linux/dma-mapping.h>
44 #define DRV_NAME "skge"
45 #define DRV_VERSION "0.7"
46 #define PFX DRV_NAME " "
48 #define DEFAULT_TX_RING_SIZE 128
49 #define DEFAULT_RX_RING_SIZE 512
50 #define MAX_TX_RING_SIZE 1024
51 #define MAX_RX_RING_SIZE 4096
52 #define RX_COPY_THRESHOLD 128
53 #define RX_BUF_SIZE 1536
54 #define PHY_RETRIES 1000
55 #define ETH_JUMBO_MTU 9000
56 #define TX_WATCHDOG (5 * HZ)
57 #define NAPI_WEIGHT 64
58 #define BLINK_HZ (HZ/4)
60 MODULE_DESCRIPTION("SysKonnect Gigabit Ethernet driver");
61 MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
62 MODULE_LICENSE("GPL");
63 MODULE_VERSION(DRV_VERSION
);
65 static const u32 default_msg
66 = NETIF_MSG_DRV
| NETIF_MSG_PROBE
| NETIF_MSG_LINK
67 | NETIF_MSG_IFUP
| NETIF_MSG_IFDOWN
;
69 static int debug
= -1; /* defaults above */
70 module_param(debug
, int, 0);
71 MODULE_PARM_DESC(debug
, "Debug level (0=none,...,16=all)");
73 static const struct pci_device_id skge_id_table
[] = {
74 { PCI_DEVICE(PCI_VENDOR_ID_3COM
, PCI_DEVICE_ID_3COM_3C940
) },
75 { PCI_DEVICE(PCI_VENDOR_ID_3COM
, PCI_DEVICE_ID_3COM_3C940B
) },
76 { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT
, PCI_DEVICE_ID_SYSKONNECT_GE
) },
77 { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT
, PCI_DEVICE_ID_SYSKONNECT_YU
) },
78 { PCI_DEVICE(PCI_VENDOR_ID_DLINK
, PCI_DEVICE_ID_DLINK_DGE510T
), },
79 { PCI_DEVICE(PCI_VENDOR_ID_MARVELL
, 0x4320) },
80 { PCI_DEVICE(PCI_VENDOR_ID_MARVELL
, 0x5005) }, /* Belkin */
81 { PCI_DEVICE(PCI_VENDOR_ID_CNET
, PCI_DEVICE_ID_CNET_GIGACARD
) },
82 { PCI_DEVICE(PCI_VENDOR_ID_LINKSYS
, PCI_DEVICE_ID_LINKSYS_EG1032
) },
83 { PCI_DEVICE(PCI_VENDOR_ID_LINKSYS
, PCI_DEVICE_ID_LINKSYS_EG1064
) },
86 MODULE_DEVICE_TABLE(pci
, skge_id_table
);
88 static int skge_up(struct net_device
*dev
);
89 static int skge_down(struct net_device
*dev
);
90 static void skge_tx_clean(struct skge_port
*skge
);
91 static void xm_phy_write(struct skge_hw
*hw
, int port
, u16 reg
, u16 val
);
92 static void gm_phy_write(struct skge_hw
*hw
, int port
, u16 reg
, u16 val
);
93 static void genesis_get_stats(struct skge_port
*skge
, u64
*data
);
94 static void yukon_get_stats(struct skge_port
*skge
, u64
*data
);
95 static void yukon_init(struct skge_hw
*hw
, int port
);
96 static void yukon_reset(struct skge_hw
*hw
, int port
);
97 static void genesis_mac_init(struct skge_hw
*hw
, int port
);
98 static void genesis_reset(struct skge_hw
*hw
, int port
);
99 static void genesis_link_up(struct skge_port
*skge
);
101 /* Avoid conditionals by using array */
102 static const int txqaddr
[] = { Q_XA1
, Q_XA2
};
103 static const int rxqaddr
[] = { Q_R1
, Q_R2
};
104 static const u32 rxirqmask
[] = { IS_R1_F
, IS_R2_F
};
105 static const u32 txirqmask
[] = { IS_XA1_F
, IS_XA2_F
};
106 static const u32 portirqmask
[] = { IS_PORT_1
, IS_PORT_2
};
108 /* Don't need to look at whole 16K.
109 * last interesting register is descriptor poll timer.
111 #define SKGE_REGS_LEN (29*128)
113 static int skge_get_regs_len(struct net_device
*dev
)
115 return SKGE_REGS_LEN
;
119 * Returns copy of control register region
120 * I/O region is divided into banks and certain regions are unreadable
122 static void skge_get_regs(struct net_device
*dev
, struct ethtool_regs
*regs
,
125 const struct skge_port
*skge
= netdev_priv(dev
);
127 const void __iomem
*io
= skge
->hw
->regs
;
128 static const unsigned long bankmap
129 = (1<<0) | (1<<2) | (1<<8) | (1<<9)
130 | (1<<12) | (1<<13) | (1<<14) | (1<<15) | (1<<16)
131 | (1<<17) | (1<<20) | (1<<21) | (1<<22) | (1<<23)
132 | (1<<24) | (1<<25) | (1<<26) | (1<<27) | (1<<28);
135 for (offs
= 0; offs
< regs
->len
; offs
+= 128) {
136 u32 len
= min_t(u32
, 128, regs
->len
- offs
);
138 if (bankmap
& (1<<(offs
/128)))
139 memcpy_fromio(p
+ offs
, io
+ offs
, len
);
141 memset(p
+ offs
, 0, len
);
145 /* Wake on Lan only supported on Yukon chps with rev 1 or above */
146 static int wol_supported(const struct skge_hw
*hw
)
148 return !((hw
->chip_id
== CHIP_ID_GENESIS
||
149 (hw
->chip_id
== CHIP_ID_YUKON
&& hw
->chip_rev
== 0)));
152 static void skge_get_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
154 struct skge_port
*skge
= netdev_priv(dev
);
156 wol
->supported
= wol_supported(skge
->hw
) ? WAKE_MAGIC
: 0;
157 wol
->wolopts
= skge
->wol
? WAKE_MAGIC
: 0;
160 static int skge_set_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
162 struct skge_port
*skge
= netdev_priv(dev
);
163 struct skge_hw
*hw
= skge
->hw
;
165 if (wol
->wolopts
!= WAKE_MAGIC
&& wol
->wolopts
!= 0)
168 if (wol
->wolopts
== WAKE_MAGIC
&& !wol_supported(hw
))
171 skge
->wol
= wol
->wolopts
== WAKE_MAGIC
;
174 memcpy_toio(hw
->regs
+ WOL_MAC_ADDR
, dev
->dev_addr
, ETH_ALEN
);
176 skge_write16(hw
, WOL_CTRL_STAT
,
177 WOL_CTL_ENA_PME_ON_MAGIC_PKT
|
178 WOL_CTL_ENA_MAGIC_PKT_UNIT
);
180 skge_write16(hw
, WOL_CTRL_STAT
, WOL_CTL_DEFAULT
);
185 /* Determine supported/adverised modes based on hardware.
186 * Note: ethtoool ADVERTISED_xxx == SUPPORTED_xxx
188 static u32
skge_supported_modes(const struct skge_hw
*hw
)
193 supported
= SUPPORTED_10baseT_Half
194 | SUPPORTED_10baseT_Full
195 | SUPPORTED_100baseT_Half
196 | SUPPORTED_100baseT_Full
197 | SUPPORTED_1000baseT_Half
198 | SUPPORTED_1000baseT_Full
199 | SUPPORTED_Autoneg
| SUPPORTED_TP
;
201 if (hw
->chip_id
== CHIP_ID_GENESIS
)
202 supported
&= ~(SUPPORTED_10baseT_Half
203 | SUPPORTED_10baseT_Full
204 | SUPPORTED_100baseT_Half
205 | SUPPORTED_100baseT_Full
);
207 else if (hw
->chip_id
== CHIP_ID_YUKON
)
208 supported
&= ~SUPPORTED_1000baseT_Half
;
210 supported
= SUPPORTED_1000baseT_Full
| SUPPORTED_FIBRE
216 static int skge_get_settings(struct net_device
*dev
,
217 struct ethtool_cmd
*ecmd
)
219 struct skge_port
*skge
= netdev_priv(dev
);
220 struct skge_hw
*hw
= skge
->hw
;
222 ecmd
->transceiver
= XCVR_INTERNAL
;
223 ecmd
->supported
= skge_supported_modes(hw
);
226 ecmd
->port
= PORT_TP
;
227 ecmd
->phy_address
= hw
->phy_addr
;
229 ecmd
->port
= PORT_FIBRE
;
231 ecmd
->advertising
= skge
->advertising
;
232 ecmd
->autoneg
= skge
->autoneg
;
233 ecmd
->speed
= skge
->speed
;
234 ecmd
->duplex
= skge
->duplex
;
238 static int skge_set_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
240 struct skge_port
*skge
= netdev_priv(dev
);
241 const struct skge_hw
*hw
= skge
->hw
;
242 u32 supported
= skge_supported_modes(hw
);
244 if (ecmd
->autoneg
== AUTONEG_ENABLE
) {
245 ecmd
->advertising
= supported
;
251 switch(ecmd
->speed
) {
253 if (ecmd
->duplex
== DUPLEX_FULL
)
254 setting
= SUPPORTED_1000baseT_Full
;
255 else if (ecmd
->duplex
== DUPLEX_HALF
)
256 setting
= SUPPORTED_1000baseT_Half
;
261 if (ecmd
->duplex
== DUPLEX_FULL
)
262 setting
= SUPPORTED_100baseT_Full
;
263 else if (ecmd
->duplex
== DUPLEX_HALF
)
264 setting
= SUPPORTED_100baseT_Half
;
270 if (ecmd
->duplex
== DUPLEX_FULL
)
271 setting
= SUPPORTED_10baseT_Full
;
272 else if (ecmd
->duplex
== DUPLEX_HALF
)
273 setting
= SUPPORTED_10baseT_Half
;
281 if ((setting
& supported
) == 0)
284 skge
->speed
= ecmd
->speed
;
285 skge
->duplex
= ecmd
->duplex
;
288 skge
->autoneg
= ecmd
->autoneg
;
289 skge
->advertising
= ecmd
->advertising
;
291 if (netif_running(dev
)) {
298 static void skge_get_drvinfo(struct net_device
*dev
,
299 struct ethtool_drvinfo
*info
)
301 struct skge_port
*skge
= netdev_priv(dev
);
303 strcpy(info
->driver
, DRV_NAME
);
304 strcpy(info
->version
, DRV_VERSION
);
305 strcpy(info
->fw_version
, "N/A");
306 strcpy(info
->bus_info
, pci_name(skge
->hw
->pdev
));
309 static const struct skge_stat
{
310 char name
[ETH_GSTRING_LEN
];
314 { "tx_bytes", XM_TXO_OK_HI
, GM_TXO_OK_HI
},
315 { "rx_bytes", XM_RXO_OK_HI
, GM_RXO_OK_HI
},
317 { "tx_broadcast", XM_TXF_BC_OK
, GM_TXF_BC_OK
},
318 { "rx_broadcast", XM_RXF_BC_OK
, GM_RXF_BC_OK
},
319 { "tx_multicast", XM_TXF_MC_OK
, GM_TXF_MC_OK
},
320 { "rx_multicast", XM_RXF_MC_OK
, GM_RXF_MC_OK
},
321 { "tx_unicast", XM_TXF_UC_OK
, GM_TXF_UC_OK
},
322 { "rx_unicast", XM_RXF_UC_OK
, GM_RXF_UC_OK
},
323 { "tx_mac_pause", XM_TXF_MPAUSE
, GM_TXF_MPAUSE
},
324 { "rx_mac_pause", XM_RXF_MPAUSE
, GM_RXF_MPAUSE
},
326 { "collisions", XM_TXF_SNG_COL
, GM_TXF_SNG_COL
},
327 { "multi_collisions", XM_TXF_MUL_COL
, GM_TXF_MUL_COL
},
328 { "aborted", XM_TXF_ABO_COL
, GM_TXF_ABO_COL
},
329 { "late_collision", XM_TXF_LAT_COL
, GM_TXF_LAT_COL
},
330 { "fifo_underrun", XM_TXE_FIFO_UR
, GM_TXE_FIFO_UR
},
331 { "fifo_overflow", XM_RXE_FIFO_OV
, GM_RXE_FIFO_OV
},
333 { "rx_toolong", XM_RXF_LNG_ERR
, GM_RXF_LNG_ERR
},
334 { "rx_jabber", XM_RXF_JAB_PKT
, GM_RXF_JAB_PKT
},
335 { "rx_runt", XM_RXE_RUNT
, GM_RXE_FRAG
},
336 { "rx_too_long", XM_RXF_LNG_ERR
, GM_RXF_LNG_ERR
},
337 { "rx_fcs_error", XM_RXF_FCS_ERR
, GM_RXF_FCS_ERR
},
340 static int skge_get_stats_count(struct net_device
*dev
)
342 return ARRAY_SIZE(skge_stats
);
345 static void skge_get_ethtool_stats(struct net_device
*dev
,
346 struct ethtool_stats
*stats
, u64
*data
)
348 struct skge_port
*skge
= netdev_priv(dev
);
350 if (skge
->hw
->chip_id
== CHIP_ID_GENESIS
)
351 genesis_get_stats(skge
, data
);
353 yukon_get_stats(skge
, data
);
356 /* Use hardware MIB variables for critical path statistics and
357 * transmit feedback not reported at interrupt.
358 * Other errors are accounted for in interrupt handler.
360 static struct net_device_stats
*skge_get_stats(struct net_device
*dev
)
362 struct skge_port
*skge
= netdev_priv(dev
);
363 u64 data
[ARRAY_SIZE(skge_stats
)];
365 if (skge
->hw
->chip_id
== CHIP_ID_GENESIS
)
366 genesis_get_stats(skge
, data
);
368 yukon_get_stats(skge
, data
);
370 skge
->net_stats
.tx_bytes
= data
[0];
371 skge
->net_stats
.rx_bytes
= data
[1];
372 skge
->net_stats
.tx_packets
= data
[2] + data
[4] + data
[6];
373 skge
->net_stats
.rx_packets
= data
[3] + data
[5] + data
[7];
374 skge
->net_stats
.multicast
= data
[5] + data
[7];
375 skge
->net_stats
.collisions
= data
[10];
376 skge
->net_stats
.tx_aborted_errors
= data
[12];
378 return &skge
->net_stats
;
381 static void skge_get_strings(struct net_device
*dev
, u32 stringset
, u8
*data
)
387 for (i
= 0; i
< ARRAY_SIZE(skge_stats
); i
++)
388 memcpy(data
+ i
* ETH_GSTRING_LEN
,
389 skge_stats
[i
].name
, ETH_GSTRING_LEN
);
394 static void skge_get_ring_param(struct net_device
*dev
,
395 struct ethtool_ringparam
*p
)
397 struct skge_port
*skge
= netdev_priv(dev
);
399 p
->rx_max_pending
= MAX_RX_RING_SIZE
;
400 p
->tx_max_pending
= MAX_TX_RING_SIZE
;
401 p
->rx_mini_max_pending
= 0;
402 p
->rx_jumbo_max_pending
= 0;
404 p
->rx_pending
= skge
->rx_ring
.count
;
405 p
->tx_pending
= skge
->tx_ring
.count
;
406 p
->rx_mini_pending
= 0;
407 p
->rx_jumbo_pending
= 0;
410 static int skge_set_ring_param(struct net_device
*dev
,
411 struct ethtool_ringparam
*p
)
413 struct skge_port
*skge
= netdev_priv(dev
);
415 if (p
->rx_pending
== 0 || p
->rx_pending
> MAX_RX_RING_SIZE
||
416 p
->tx_pending
== 0 || p
->tx_pending
> MAX_TX_RING_SIZE
)
419 skge
->rx_ring
.count
= p
->rx_pending
;
420 skge
->tx_ring
.count
= p
->tx_pending
;
422 if (netif_running(dev
)) {
430 static u32
skge_get_msglevel(struct net_device
*netdev
)
432 struct skge_port
*skge
= netdev_priv(netdev
);
433 return skge
->msg_enable
;
436 static void skge_set_msglevel(struct net_device
*netdev
, u32 value
)
438 struct skge_port
*skge
= netdev_priv(netdev
);
439 skge
->msg_enable
= value
;
442 static int skge_nway_reset(struct net_device
*dev
)
444 struct skge_port
*skge
= netdev_priv(dev
);
445 struct skge_hw
*hw
= skge
->hw
;
446 int port
= skge
->port
;
448 if (skge
->autoneg
!= AUTONEG_ENABLE
|| !netif_running(dev
))
451 spin_lock_bh(&hw
->phy_lock
);
452 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
453 genesis_reset(hw
, port
);
454 genesis_mac_init(hw
, port
);
456 yukon_reset(hw
, port
);
457 yukon_init(hw
, port
);
459 spin_unlock_bh(&hw
->phy_lock
);
463 static int skge_set_sg(struct net_device
*dev
, u32 data
)
465 struct skge_port
*skge
= netdev_priv(dev
);
466 struct skge_hw
*hw
= skge
->hw
;
468 if (hw
->chip_id
== CHIP_ID_GENESIS
&& data
)
470 return ethtool_op_set_sg(dev
, data
);
473 static int skge_set_tx_csum(struct net_device
*dev
, u32 data
)
475 struct skge_port
*skge
= netdev_priv(dev
);
476 struct skge_hw
*hw
= skge
->hw
;
478 if (hw
->chip_id
== CHIP_ID_GENESIS
&& data
)
481 return ethtool_op_set_tx_csum(dev
, data
);
484 static u32
skge_get_rx_csum(struct net_device
*dev
)
486 struct skge_port
*skge
= netdev_priv(dev
);
488 return skge
->rx_csum
;
491 /* Only Yukon supports checksum offload. */
492 static int skge_set_rx_csum(struct net_device
*dev
, u32 data
)
494 struct skge_port
*skge
= netdev_priv(dev
);
496 if (skge
->hw
->chip_id
== CHIP_ID_GENESIS
&& data
)
499 skge
->rx_csum
= data
;
503 static void skge_get_pauseparam(struct net_device
*dev
,
504 struct ethtool_pauseparam
*ecmd
)
506 struct skge_port
*skge
= netdev_priv(dev
);
508 ecmd
->tx_pause
= (skge
->flow_control
== FLOW_MODE_LOC_SEND
)
509 || (skge
->flow_control
== FLOW_MODE_SYMMETRIC
);
510 ecmd
->rx_pause
= (skge
->flow_control
== FLOW_MODE_REM_SEND
)
511 || (skge
->flow_control
== FLOW_MODE_SYMMETRIC
);
513 ecmd
->autoneg
= skge
->autoneg
;
516 static int skge_set_pauseparam(struct net_device
*dev
,
517 struct ethtool_pauseparam
*ecmd
)
519 struct skge_port
*skge
= netdev_priv(dev
);
521 skge
->autoneg
= ecmd
->autoneg
;
522 if (ecmd
->rx_pause
&& ecmd
->tx_pause
)
523 skge
->flow_control
= FLOW_MODE_SYMMETRIC
;
524 else if (ecmd
->rx_pause
&& !ecmd
->tx_pause
)
525 skge
->flow_control
= FLOW_MODE_REM_SEND
;
526 else if (!ecmd
->rx_pause
&& ecmd
->tx_pause
)
527 skge
->flow_control
= FLOW_MODE_LOC_SEND
;
529 skge
->flow_control
= FLOW_MODE_NONE
;
531 if (netif_running(dev
)) {
538 /* Chip internal frequency for clock calculations */
539 static inline u32
hwkhz(const struct skge_hw
*hw
)
541 if (hw
->chip_id
== CHIP_ID_GENESIS
)
542 return 53215; /* or: 53.125 MHz */
544 return 78215; /* or: 78.125 MHz */
547 /* Chip hz to microseconds */
548 static inline u32
skge_clk2usec(const struct skge_hw
*hw
, u32 ticks
)
550 return (ticks
* 1000) / hwkhz(hw
);
553 /* Microseconds to chip hz */
554 static inline u32
skge_usecs2clk(const struct skge_hw
*hw
, u32 usec
)
556 return hwkhz(hw
) * usec
/ 1000;
559 static int skge_get_coalesce(struct net_device
*dev
,
560 struct ethtool_coalesce
*ecmd
)
562 struct skge_port
*skge
= netdev_priv(dev
);
563 struct skge_hw
*hw
= skge
->hw
;
564 int port
= skge
->port
;
566 ecmd
->rx_coalesce_usecs
= 0;
567 ecmd
->tx_coalesce_usecs
= 0;
569 if (skge_read32(hw
, B2_IRQM_CTRL
) & TIM_START
) {
570 u32 delay
= skge_clk2usec(hw
, skge_read32(hw
, B2_IRQM_INI
));
571 u32 msk
= skge_read32(hw
, B2_IRQM_MSK
);
573 if (msk
& rxirqmask
[port
])
574 ecmd
->rx_coalesce_usecs
= delay
;
575 if (msk
& txirqmask
[port
])
576 ecmd
->tx_coalesce_usecs
= delay
;
582 /* Note: interrupt timer is per board, but can turn on/off per port */
583 static int skge_set_coalesce(struct net_device
*dev
,
584 struct ethtool_coalesce
*ecmd
)
586 struct skge_port
*skge
= netdev_priv(dev
);
587 struct skge_hw
*hw
= skge
->hw
;
588 int port
= skge
->port
;
589 u32 msk
= skge_read32(hw
, B2_IRQM_MSK
);
592 if (ecmd
->rx_coalesce_usecs
== 0)
593 msk
&= ~rxirqmask
[port
];
594 else if (ecmd
->rx_coalesce_usecs
< 25 ||
595 ecmd
->rx_coalesce_usecs
> 33333)
598 msk
|= rxirqmask
[port
];
599 delay
= ecmd
->rx_coalesce_usecs
;
602 if (ecmd
->tx_coalesce_usecs
== 0)
603 msk
&= ~txirqmask
[port
];
604 else if (ecmd
->tx_coalesce_usecs
< 25 ||
605 ecmd
->tx_coalesce_usecs
> 33333)
608 msk
|= txirqmask
[port
];
609 delay
= min(delay
, ecmd
->rx_coalesce_usecs
);
612 skge_write32(hw
, B2_IRQM_MSK
, msk
);
614 skge_write32(hw
, B2_IRQM_CTRL
, TIM_STOP
);
616 skge_write32(hw
, B2_IRQM_INI
, skge_usecs2clk(hw
, delay
));
617 skge_write32(hw
, B2_IRQM_CTRL
, TIM_START
);
622 static void skge_led_on(struct skge_hw
*hw
, int port
)
624 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
625 skge_write8(hw
, SK_REG(port
, LNK_LED_REG
), LINKLED_ON
);
626 skge_write8(hw
, B0_LED
, LED_STAT_ON
);
628 skge_write8(hw
, SK_REG(port
, RX_LED_TST
), LED_T_ON
);
629 skge_write32(hw
, SK_REG(port
, RX_LED_VAL
), 100);
630 skge_write8(hw
, SK_REG(port
, RX_LED_CTRL
), LED_START
);
632 /* For Broadcom Phy only */
633 xm_phy_write(hw
, port
, PHY_BCOM_P_EXT_CTRL
, PHY_B_PEC_LED_ON
);
635 gm_phy_write(hw
, port
, PHY_MARV_LED_CTRL
, 0);
636 gm_phy_write(hw
, port
, PHY_MARV_LED_OVER
,
637 PHY_M_LED_MO_DUP(MO_LED_ON
) |
638 PHY_M_LED_MO_10(MO_LED_ON
) |
639 PHY_M_LED_MO_100(MO_LED_ON
) |
640 PHY_M_LED_MO_1000(MO_LED_ON
) |
641 PHY_M_LED_MO_RX(MO_LED_ON
));
645 static void skge_led_off(struct skge_hw
*hw
, int port
)
647 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
648 skge_write8(hw
, SK_REG(port
, LNK_LED_REG
), LINKLED_OFF
);
649 skge_write8(hw
, B0_LED
, LED_STAT_OFF
);
651 skge_write32(hw
, SK_REG(port
, RX_LED_VAL
), 0);
652 skge_write8(hw
, SK_REG(port
, RX_LED_CTRL
), LED_T_OFF
);
655 xm_phy_write(hw
, port
, PHY_BCOM_P_EXT_CTRL
, PHY_B_PEC_LED_OFF
);
657 gm_phy_write(hw
, port
, PHY_MARV_LED_CTRL
, 0);
658 gm_phy_write(hw
, port
, PHY_MARV_LED_OVER
,
659 PHY_M_LED_MO_DUP(MO_LED_OFF
) |
660 PHY_M_LED_MO_10(MO_LED_OFF
) |
661 PHY_M_LED_MO_100(MO_LED_OFF
) |
662 PHY_M_LED_MO_1000(MO_LED_OFF
) |
663 PHY_M_LED_MO_RX(MO_LED_OFF
));
667 static void skge_blink_timer(unsigned long data
)
669 struct skge_port
*skge
= (struct skge_port
*) data
;
670 struct skge_hw
*hw
= skge
->hw
;
673 spin_lock_irqsave(&hw
->phy_lock
, flags
);
675 skge_led_on(hw
, skge
->port
);
677 skge_led_off(hw
, skge
->port
);
678 spin_unlock_irqrestore(&hw
->phy_lock
, flags
);
680 skge
->blink_on
= !skge
->blink_on
;
681 mod_timer(&skge
->led_blink
, jiffies
+ BLINK_HZ
);
684 /* blink LED's for finding board */
685 static int skge_phys_id(struct net_device
*dev
, u32 data
)
687 struct skge_port
*skge
= netdev_priv(dev
);
689 if (!data
|| data
> (u32
)(MAX_SCHEDULE_TIMEOUT
/ HZ
))
690 data
= (u32
)(MAX_SCHEDULE_TIMEOUT
/ HZ
);
694 mod_timer(&skge
->led_blink
, jiffies
+1);
696 msleep_interruptible(data
* 1000);
697 del_timer_sync(&skge
->led_blink
);
699 skge_led_off(skge
->hw
, skge
->port
);
704 static struct ethtool_ops skge_ethtool_ops
= {
705 .get_settings
= skge_get_settings
,
706 .set_settings
= skge_set_settings
,
707 .get_drvinfo
= skge_get_drvinfo
,
708 .get_regs_len
= skge_get_regs_len
,
709 .get_regs
= skge_get_regs
,
710 .get_wol
= skge_get_wol
,
711 .set_wol
= skge_set_wol
,
712 .get_msglevel
= skge_get_msglevel
,
713 .set_msglevel
= skge_set_msglevel
,
714 .nway_reset
= skge_nway_reset
,
715 .get_link
= ethtool_op_get_link
,
716 .get_ringparam
= skge_get_ring_param
,
717 .set_ringparam
= skge_set_ring_param
,
718 .get_pauseparam
= skge_get_pauseparam
,
719 .set_pauseparam
= skge_set_pauseparam
,
720 .get_coalesce
= skge_get_coalesce
,
721 .set_coalesce
= skge_set_coalesce
,
722 .get_sg
= ethtool_op_get_sg
,
723 .set_sg
= skge_set_sg
,
724 .get_tx_csum
= ethtool_op_get_tx_csum
,
725 .set_tx_csum
= skge_set_tx_csum
,
726 .get_rx_csum
= skge_get_rx_csum
,
727 .set_rx_csum
= skge_set_rx_csum
,
728 .get_strings
= skge_get_strings
,
729 .phys_id
= skge_phys_id
,
730 .get_stats_count
= skge_get_stats_count
,
731 .get_ethtool_stats
= skge_get_ethtool_stats
,
735 * Allocate ring elements and chain them together
736 * One-to-one association of board descriptors with ring elements
738 static int skge_ring_alloc(struct skge_ring
*ring
, void *vaddr
, u64 base
)
740 struct skge_tx_desc
*d
;
741 struct skge_element
*e
;
744 ring
->start
= kmalloc(sizeof(*e
)*ring
->count
, GFP_KERNEL
);
748 for (i
= 0, e
= ring
->start
, d
= vaddr
; i
< ring
->count
; i
++, e
++, d
++) {
751 if (i
== ring
->count
- 1) {
752 e
->next
= ring
->start
;
753 d
->next_offset
= base
;
756 d
->next_offset
= base
+ (i
+1) * sizeof(*d
);
759 ring
->to_use
= ring
->to_clean
= ring
->start
;
764 static struct sk_buff
*skge_rx_alloc(struct net_device
*dev
, unsigned int size
)
766 struct sk_buff
*skb
= dev_alloc_skb(size
);
770 skb_reserve(skb
, NET_IP_ALIGN
);
775 /* Allocate and setup a new buffer for receiving */
776 static void skge_rx_setup(struct skge_port
*skge
, struct skge_element
*e
,
777 struct sk_buff
*skb
, unsigned int bufsize
)
779 struct skge_rx_desc
*rd
= e
->desc
;
782 map
= pci_map_single(skge
->hw
->pdev
, skb
->data
, bufsize
,
786 rd
->dma_hi
= map
>> 32;
788 rd
->csum1_start
= ETH_HLEN
;
789 rd
->csum2_start
= ETH_HLEN
;
795 rd
->control
= BMU_OWN
| BMU_STF
| BMU_IRQ_EOF
| BMU_TCP_CHECK
| bufsize
;
796 pci_unmap_addr_set(e
, mapaddr
, map
);
797 pci_unmap_len_set(e
, maplen
, bufsize
);
800 /* Resume receiving using existing skb,
801 * Note: DMA address is not changed by chip.
802 * MTU not changed while receiver active.
804 static void skge_rx_reuse(struct skge_element
*e
, unsigned int size
)
806 struct skge_rx_desc
*rd
= e
->desc
;
809 rd
->csum2_start
= ETH_HLEN
;
813 rd
->control
= BMU_OWN
| BMU_STF
| BMU_IRQ_EOF
| BMU_TCP_CHECK
| size
;
817 /* Free all buffers in receive ring, assumes receiver stopped */
818 static void skge_rx_clean(struct skge_port
*skge
)
820 struct skge_hw
*hw
= skge
->hw
;
821 struct skge_ring
*ring
= &skge
->rx_ring
;
822 struct skge_element
*e
;
826 struct skge_rx_desc
*rd
= e
->desc
;
829 pci_unmap_single(hw
->pdev
,
830 pci_unmap_addr(e
, mapaddr
),
831 pci_unmap_len(e
, maplen
),
833 dev_kfree_skb(e
->skb
);
836 } while ((e
= e
->next
) != ring
->start
);
840 /* Allocate buffers for receive ring
841 * For receive: to_clean is next received frame.
843 static int skge_rx_fill(struct skge_port
*skge
)
845 struct skge_ring
*ring
= &skge
->rx_ring
;
846 struct skge_element
*e
;
847 unsigned int bufsize
= skge
->rx_buf_size
;
851 struct sk_buff
*skb
= skge_rx_alloc(skge
->netdev
, bufsize
);
856 skge_rx_setup(skge
, e
, skb
, bufsize
);
857 } while ( (e
= e
->next
) != ring
->start
);
859 ring
->to_clean
= ring
->start
;
863 static void skge_link_up(struct skge_port
*skge
)
865 netif_carrier_on(skge
->netdev
);
866 if (skge
->tx_avail
> MAX_SKB_FRAGS
+ 1)
867 netif_wake_queue(skge
->netdev
);
869 if (netif_msg_link(skge
))
871 "%s: Link is up at %d Mbps, %s duplex, flow control %s\n",
872 skge
->netdev
->name
, skge
->speed
,
873 skge
->duplex
== DUPLEX_FULL
? "full" : "half",
874 (skge
->flow_control
== FLOW_MODE_NONE
) ? "none" :
875 (skge
->flow_control
== FLOW_MODE_LOC_SEND
) ? "tx only" :
876 (skge
->flow_control
== FLOW_MODE_REM_SEND
) ? "rx only" :
877 (skge
->flow_control
== FLOW_MODE_SYMMETRIC
) ? "tx and rx" :
881 static void skge_link_down(struct skge_port
*skge
)
883 netif_carrier_off(skge
->netdev
);
884 netif_stop_queue(skge
->netdev
);
886 if (netif_msg_link(skge
))
887 printk(KERN_INFO PFX
"%s: Link is down.\n", skge
->netdev
->name
);
890 static u16
xm_phy_read(struct skge_hw
*hw
, int port
, u16 reg
)
895 xm_write16(hw
, port
, XM_PHY_ADDR
, reg
| hw
->phy_addr
);
896 v
= xm_read16(hw
, port
, XM_PHY_DATA
);
898 /* Need to wait for external PHY */
899 for (i
= 0; i
< PHY_RETRIES
; i
++) {
901 if (xm_read16(hw
, port
, XM_MMU_CMD
)
906 printk(KERN_WARNING PFX
"%s: phy read timed out\n",
907 hw
->dev
[port
]->name
);
910 v
= xm_read16(hw
, port
, XM_PHY_DATA
);
915 static void xm_phy_write(struct skge_hw
*hw
, int port
, u16 reg
, u16 val
)
919 xm_write16(hw
, port
, XM_PHY_ADDR
, reg
| hw
->phy_addr
);
920 for (i
= 0; i
< PHY_RETRIES
; i
++) {
921 if (!(xm_read16(hw
, port
, XM_MMU_CMD
) & XM_MMU_PHY_BUSY
))
925 printk(KERN_WARNING PFX
"%s: phy write failed to come ready\n",
926 hw
->dev
[port
]->name
);
930 xm_write16(hw
, port
, XM_PHY_DATA
, val
);
931 for (i
= 0; i
< PHY_RETRIES
; i
++) {
933 if (!(xm_read16(hw
, port
, XM_MMU_CMD
) & XM_MMU_PHY_BUSY
))
936 printk(KERN_WARNING PFX
"%s: phy write timed out\n",
937 hw
->dev
[port
]->name
);
940 static void genesis_init(struct skge_hw
*hw
)
942 /* set blink source counter */
943 skge_write32(hw
, B2_BSC_INI
, (SK_BLK_DUR
* SK_FACT_53
) / 100);
944 skge_write8(hw
, B2_BSC_CTRL
, BSC_START
);
946 /* configure mac arbiter */
947 skge_write16(hw
, B3_MA_TO_CTRL
, MA_RST_CLR
);
949 /* configure mac arbiter timeout values */
950 skge_write8(hw
, B3_MA_TOINI_RX1
, SK_MAC_TO_53
);
951 skge_write8(hw
, B3_MA_TOINI_RX2
, SK_MAC_TO_53
);
952 skge_write8(hw
, B3_MA_TOINI_TX1
, SK_MAC_TO_53
);
953 skge_write8(hw
, B3_MA_TOINI_TX2
, SK_MAC_TO_53
);
955 skge_write8(hw
, B3_MA_RCINI_RX1
, 0);
956 skge_write8(hw
, B3_MA_RCINI_RX2
, 0);
957 skge_write8(hw
, B3_MA_RCINI_TX1
, 0);
958 skge_write8(hw
, B3_MA_RCINI_TX2
, 0);
960 /* configure packet arbiter timeout */
961 skge_write16(hw
, B3_PA_CTRL
, PA_RST_CLR
);
962 skge_write16(hw
, B3_PA_TOINI_RX1
, SK_PKT_TO_MAX
);
963 skge_write16(hw
, B3_PA_TOINI_TX1
, SK_PKT_TO_MAX
);
964 skge_write16(hw
, B3_PA_TOINI_RX2
, SK_PKT_TO_MAX
);
965 skge_write16(hw
, B3_PA_TOINI_TX2
, SK_PKT_TO_MAX
);
968 static void genesis_reset(struct skge_hw
*hw
, int port
)
970 const u8 zero
[8] = { 0 };
972 /* reset the statistics module */
973 xm_write32(hw
, port
, XM_GP_PORT
, XM_GP_RES_STAT
);
974 xm_write16(hw
, port
, XM_IMSK
, 0xffff); /* disable XMAC IRQs */
975 xm_write32(hw
, port
, XM_MODE
, 0); /* clear Mode Reg */
976 xm_write16(hw
, port
, XM_TX_CMD
, 0); /* reset TX CMD Reg */
977 xm_write16(hw
, port
, XM_RX_CMD
, 0); /* reset RX CMD Reg */
979 /* disable Broadcom PHY IRQ */
980 xm_write16(hw
, port
, PHY_BCOM_INT_MASK
, 0xffff);
982 xm_outhash(hw
, port
, XM_HSM
, zero
);
986 /* Convert mode to MII values */
987 static const u16 phy_pause_map
[] = {
988 [FLOW_MODE_NONE
] = 0,
989 [FLOW_MODE_LOC_SEND
] = PHY_AN_PAUSE_ASYM
,
990 [FLOW_MODE_SYMMETRIC
] = PHY_AN_PAUSE_CAP
,
991 [FLOW_MODE_REM_SEND
] = PHY_AN_PAUSE_CAP
| PHY_AN_PAUSE_ASYM
,
995 /* Check status of Broadcom phy link */
996 static void bcom_check_link(struct skge_hw
*hw
, int port
)
998 struct net_device
*dev
= hw
->dev
[port
];
999 struct skge_port
*skge
= netdev_priv(dev
);
1002 /* read twice because of latch */
1003 (void) xm_phy_read(hw
, port
, PHY_BCOM_STAT
);
1004 status
= xm_phy_read(hw
, port
, PHY_BCOM_STAT
);
1006 pr_debug("bcom_check_link status=0x%x\n", status
);
1008 if ((status
& PHY_ST_LSYNC
) == 0) {
1009 u16 cmd
= xm_read16(hw
, port
, XM_MMU_CMD
);
1010 cmd
&= ~(XM_MMU_ENA_RX
| XM_MMU_ENA_TX
);
1011 xm_write16(hw
, port
, XM_MMU_CMD
, cmd
);
1012 /* dummy read to ensure writing */
1013 (void) xm_read16(hw
, port
, XM_MMU_CMD
);
1015 if (netif_carrier_ok(dev
))
1016 skge_link_down(skge
);
1018 if (skge
->autoneg
== AUTONEG_ENABLE
&&
1019 (status
& PHY_ST_AN_OVER
)) {
1020 u16 lpa
= xm_phy_read(hw
, port
, PHY_BCOM_AUNE_LP
);
1021 u16 aux
= xm_phy_read(hw
, port
, PHY_BCOM_AUX_STAT
);
1023 if (lpa
& PHY_B_AN_RF
) {
1024 printk(KERN_NOTICE PFX
"%s: remote fault\n",
1029 /* Check Duplex mismatch */
1030 switch(aux
& PHY_B_AS_AN_RES_MSK
) {
1031 case PHY_B_RES_1000FD
:
1032 skge
->duplex
= DUPLEX_FULL
;
1034 case PHY_B_RES_1000HD
:
1035 skge
->duplex
= DUPLEX_HALF
;
1038 printk(KERN_NOTICE PFX
"%s: duplex mismatch\n",
1044 /* We are using IEEE 802.3z/D5.0 Table 37-4 */
1045 switch (aux
& PHY_B_AS_PAUSE_MSK
) {
1046 case PHY_B_AS_PAUSE_MSK
:
1047 skge
->flow_control
= FLOW_MODE_SYMMETRIC
;
1050 skge
->flow_control
= FLOW_MODE_REM_SEND
;
1053 skge
->flow_control
= FLOW_MODE_LOC_SEND
;
1056 skge
->flow_control
= FLOW_MODE_NONE
;
1059 skge
->speed
= SPEED_1000
;
1062 if (!netif_carrier_ok(dev
))
1063 genesis_link_up(skge
);
1067 /* Broadcom 5400 only supports giagabit! SysKonnect did not put an additional
1068 * Phy on for 100 or 10Mbit operation
1070 static void bcom_phy_init(struct skge_port
*skge
, int jumbo
)
1072 struct skge_hw
*hw
= skge
->hw
;
1073 int port
= skge
->port
;
1075 u16 id1
, r
, ext
, ctl
;
1077 /* magic workaround patterns for Broadcom */
1078 static const struct {
1082 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1104 },
1083 { 0x17, 0x0013 }, { 0x15, 0x0404 }, { 0x17, 0x8006 },
1084 { 0x15, 0x0132 }, { 0x17, 0x8006 }, { 0x15, 0x0232 },
1085 { 0x17, 0x800D }, { 0x15, 0x000F }, { 0x18, 0x0420 },
1087 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1204 },
1088 { 0x17, 0x0013 }, { 0x15, 0x0A04 }, { 0x18, 0x0420 },
1091 pr_debug("bcom_phy_init\n");
1093 /* read Id from external PHY (all have the same address) */
1094 id1
= xm_phy_read(hw
, port
, PHY_XMAC_ID1
);
1096 /* Optimize MDIO transfer by suppressing preamble. */
1097 r
= xm_read16(hw
, port
, XM_MMU_CMD
);
1099 xm_write16(hw
, port
, XM_MMU_CMD
,r
);
1102 case PHY_BCOM_ID1_C0
:
1104 * Workaround BCOM Errata for the C0 type.
1105 * Write magic patterns to reserved registers.
1107 for (i
= 0; i
< ARRAY_SIZE(C0hack
); i
++)
1108 xm_phy_write(hw
, port
,
1109 C0hack
[i
].reg
, C0hack
[i
].val
);
1112 case PHY_BCOM_ID1_A1
:
1114 * Workaround BCOM Errata for the A1 type.
1115 * Write magic patterns to reserved registers.
1117 for (i
= 0; i
< ARRAY_SIZE(A1hack
); i
++)
1118 xm_phy_write(hw
, port
,
1119 A1hack
[i
].reg
, A1hack
[i
].val
);
1124 * Workaround BCOM Errata (#10523) for all BCom PHYs.
1125 * Disable Power Management after reset.
1127 r
= xm_phy_read(hw
, port
, PHY_BCOM_AUX_CTRL
);
1128 r
|= PHY_B_AC_DIS_PM
;
1129 xm_phy_write(hw
, port
, PHY_BCOM_AUX_CTRL
, r
);
1132 xm_read16(hw
, port
, XM_ISRC
);
1134 ext
= PHY_B_PEC_EN_LTR
; /* enable tx led */
1135 ctl
= PHY_CT_SP1000
; /* always 1000mbit */
1137 if (skge
->autoneg
== AUTONEG_ENABLE
) {
1139 * Workaround BCOM Errata #1 for the C5 type.
1140 * 1000Base-T Link Acquisition Failure in Slave Mode
1141 * Set Repeater/DTE bit 10 of the 1000Base-T Control Register
1143 u16 adv
= PHY_B_1000C_RD
;
1144 if (skge
->advertising
& ADVERTISED_1000baseT_Half
)
1145 adv
|= PHY_B_1000C_AHD
;
1146 if (skge
->advertising
& ADVERTISED_1000baseT_Full
)
1147 adv
|= PHY_B_1000C_AFD
;
1148 xm_phy_write(hw
, port
, PHY_BCOM_1000T_CTRL
, adv
);
1150 ctl
|= PHY_CT_ANE
| PHY_CT_RE_CFG
;
1152 if (skge
->duplex
== DUPLEX_FULL
)
1153 ctl
|= PHY_CT_DUP_MD
;
1154 /* Force to slave */
1155 xm_phy_write(hw
, port
, PHY_BCOM_1000T_CTRL
, PHY_B_1000C_MSE
);
1158 /* Set autonegotiation pause parameters */
1159 xm_phy_write(hw
, port
, PHY_BCOM_AUNE_ADV
,
1160 phy_pause_map
[skge
->flow_control
] | PHY_AN_CSMA
);
1162 /* Handle Jumbo frames */
1164 xm_phy_write(hw
, port
, PHY_BCOM_AUX_CTRL
,
1165 PHY_B_AC_TX_TST
| PHY_B_AC_LONG_PACK
);
1167 ext
|= PHY_B_PEC_HIGH_LA
;
1171 xm_phy_write(hw
, port
, PHY_BCOM_P_EXT_CTRL
, ext
);
1172 xm_phy_write(hw
, port
, PHY_BCOM_CTRL
, ctl
);
1174 /* Use link status change interrrupt */
1175 xm_phy_write(hw
, port
, PHY_BCOM_INT_MASK
, PHY_B_DEF_MSK
);
1177 bcom_check_link(hw
, port
);
1180 static void genesis_mac_init(struct skge_hw
*hw
, int port
)
1182 struct net_device
*dev
= hw
->dev
[port
];
1183 struct skge_port
*skge
= netdev_priv(dev
);
1184 int jumbo
= hw
->dev
[port
]->mtu
> ETH_DATA_LEN
;
1187 const u8 zero
[6] = { 0 };
1189 /* Clear MIB counters */
1190 xm_write16(hw
, port
, XM_STAT_CMD
,
1191 XM_SC_CLR_RXC
| XM_SC_CLR_TXC
);
1192 /* Clear two times according to Errata #3 */
1193 xm_write16(hw
, port
, XM_STAT_CMD
,
1194 XM_SC_CLR_RXC
| XM_SC_CLR_TXC
);
1196 /* initialize Rx, Tx and Link LED */
1197 skge_write8(hw
, SK_REG(port
, LNK_LED_REG
), LINKLED_ON
);
1198 skge_write8(hw
, SK_REG(port
, LNK_LED_REG
), LINKLED_LINKSYNC_ON
);
1200 skge_write8(hw
, SK_REG(port
, RX_LED_CTRL
), LED_START
);
1201 skge_write8(hw
, SK_REG(port
, TX_LED_CTRL
), LED_START
);
1203 /* Unreset the XMAC. */
1204 skge_write16(hw
, SK_REG(port
, TX_MFF_CTRL1
), MFF_CLR_MAC_RST
);
1207 * Perform additional initialization for external PHYs,
1208 * namely for the 1000baseTX cards that use the XMAC's
1211 spin_lock_bh(&hw
->phy_lock
);
1212 /* Take external Phy out of reset */
1213 r
= skge_read32(hw
, B2_GP_IO
);
1215 r
|= GP_DIR_0
|GP_IO_0
;
1217 r
|= GP_DIR_2
|GP_IO_2
;
1219 skge_write32(hw
, B2_GP_IO
, r
);
1220 skge_read32(hw
, B2_GP_IO
);
1221 spin_unlock_bh(&hw
->phy_lock
);
1223 /* Enable GMII interfac */
1224 xm_write16(hw
, port
, XM_HW_CFG
, XM_HW_GMII_MD
);
1226 bcom_phy_init(skge
, jumbo
);
1228 /* Set Station Address */
1229 xm_outaddr(hw
, port
, XM_SA
, dev
->dev_addr
);
1231 /* We don't use match addresses so clear */
1232 for (i
= 1; i
< 16; i
++)
1233 xm_outaddr(hw
, port
, XM_EXM(i
), zero
);
1235 /* configure Rx High Water Mark (XM_RX_HI_WM) */
1236 xm_write16(hw
, port
, XM_RX_HI_WM
, 1450);
1238 /* We don't need the FCS appended to the packet. */
1239 r
= XM_RX_LENERR_OK
| XM_RX_STRIP_FCS
;
1241 r
|= XM_RX_BIG_PK_OK
;
1243 if (skge
->duplex
== DUPLEX_HALF
) {
1245 * If in manual half duplex mode the other side might be in
1246 * full duplex mode, so ignore if a carrier extension is not seen
1247 * on frames received
1249 r
|= XM_RX_DIS_CEXT
;
1251 xm_write16(hw
, port
, XM_RX_CMD
, r
);
1254 /* We want short frames padded to 60 bytes. */
1255 xm_write16(hw
, port
, XM_TX_CMD
, XM_TX_AUTO_PAD
);
1258 * Bump up the transmit threshold. This helps hold off transmit
1259 * underruns when we're blasting traffic from both ports at once.
1261 xm_write16(hw
, port
, XM_TX_THR
, 512);
1264 * Enable the reception of all error frames. This is is
1265 * a necessary evil due to the design of the XMAC. The
1266 * XMAC's receive FIFO is only 8K in size, however jumbo
1267 * frames can be up to 9000 bytes in length. When bad
1268 * frame filtering is enabled, the XMAC's RX FIFO operates
1269 * in 'store and forward' mode. For this to work, the
1270 * entire frame has to fit into the FIFO, but that means
1271 * that jumbo frames larger than 8192 bytes will be
1272 * truncated. Disabling all bad frame filtering causes
1273 * the RX FIFO to operate in streaming mode, in which
1274 * case the XMAC will start transfering frames out of the
1275 * RX FIFO as soon as the FIFO threshold is reached.
1277 xm_write32(hw
, port
, XM_MODE
, XM_DEF_MODE
);
1281 * Initialize the Receive Counter Event Mask (XM_RX_EV_MSK)
1282 * - Enable all bits excepting 'Octets Rx OK Low CntOv'
1283 * and 'Octets Rx OK Hi Cnt Ov'.
1285 xm_write32(hw
, port
, XM_RX_EV_MSK
, XMR_DEF_MSK
);
1288 * Initialize the Transmit Counter Event Mask (XM_TX_EV_MSK)
1289 * - Enable all bits excepting 'Octets Tx OK Low CntOv'
1290 * and 'Octets Tx OK Hi Cnt Ov'.
1292 xm_write32(hw
, port
, XM_TX_EV_MSK
, XMT_DEF_MSK
);
1294 /* Configure MAC arbiter */
1295 skge_write16(hw
, B3_MA_TO_CTRL
, MA_RST_CLR
);
1297 /* configure timeout values */
1298 skge_write8(hw
, B3_MA_TOINI_RX1
, 72);
1299 skge_write8(hw
, B3_MA_TOINI_RX2
, 72);
1300 skge_write8(hw
, B3_MA_TOINI_TX1
, 72);
1301 skge_write8(hw
, B3_MA_TOINI_TX2
, 72);
1303 skge_write8(hw
, B3_MA_RCINI_RX1
, 0);
1304 skge_write8(hw
, B3_MA_RCINI_RX2
, 0);
1305 skge_write8(hw
, B3_MA_RCINI_TX1
, 0);
1306 skge_write8(hw
, B3_MA_RCINI_TX2
, 0);
1308 /* Configure Rx MAC FIFO */
1309 skge_write8(hw
, SK_REG(port
, RX_MFF_CTRL2
), MFF_RST_CLR
);
1310 skge_write16(hw
, SK_REG(port
, RX_MFF_CTRL1
), MFF_ENA_TIM_PAT
);
1311 skge_write8(hw
, SK_REG(port
, RX_MFF_CTRL2
), MFF_ENA_OP_MD
);
1313 /* Configure Tx MAC FIFO */
1314 skge_write8(hw
, SK_REG(port
, TX_MFF_CTRL2
), MFF_RST_CLR
);
1315 skge_write16(hw
, SK_REG(port
, TX_MFF_CTRL1
), MFF_TX_CTRL_DEF
);
1316 skge_write8(hw
, SK_REG(port
, TX_MFF_CTRL2
), MFF_ENA_OP_MD
);
1319 /* Enable frame flushing if jumbo frames used */
1320 skge_write16(hw
, SK_REG(port
,RX_MFF_CTRL1
), MFF_ENA_FLUSH
);
1322 /* enable timeout timers if normal frames */
1323 skge_write16(hw
, B3_PA_CTRL
,
1324 (port
== 0) ? PA_ENA_TO_TX1
: PA_ENA_TO_TX2
);
1328 static void genesis_stop(struct skge_port
*skge
)
1330 struct skge_hw
*hw
= skge
->hw
;
1331 int port
= skge
->port
;
1334 /* Clear Tx packet arbiter timeout IRQ */
1335 skge_write16(hw
, B3_PA_CTRL
,
1336 port
== 0 ? PA_CLR_TO_TX1
: PA_CLR_TO_TX2
);
1339 * If the transfer stucks at the MAC the STOP command will not
1340 * terminate if we don't flush the XMAC's transmit FIFO !
1342 xm_write32(hw
, port
, XM_MODE
,
1343 xm_read32(hw
, port
, XM_MODE
)|XM_MD_FTF
);
1347 skge_write16(hw
, SK_REG(port
, TX_MFF_CTRL1
), MFF_SET_MAC_RST
);
1349 /* For external PHYs there must be special handling */
1350 reg
= skge_read32(hw
, B2_GP_IO
);
1358 skge_write32(hw
, B2_GP_IO
, reg
);
1359 skge_read32(hw
, B2_GP_IO
);
1361 xm_write16(hw
, port
, XM_MMU_CMD
,
1362 xm_read16(hw
, port
, XM_MMU_CMD
)
1363 & ~(XM_MMU_ENA_RX
| XM_MMU_ENA_TX
));
1365 xm_read16(hw
, port
, XM_MMU_CMD
);
1369 static void genesis_get_stats(struct skge_port
*skge
, u64
*data
)
1371 struct skge_hw
*hw
= skge
->hw
;
1372 int port
= skge
->port
;
1374 unsigned long timeout
= jiffies
+ HZ
;
1376 xm_write16(hw
, port
,
1377 XM_STAT_CMD
, XM_SC_SNP_TXC
| XM_SC_SNP_RXC
);
1379 /* wait for update to complete */
1380 while (xm_read16(hw
, port
, XM_STAT_CMD
)
1381 & (XM_SC_SNP_TXC
| XM_SC_SNP_RXC
)) {
1382 if (time_after(jiffies
, timeout
))
1387 /* special case for 64 bit octet counter */
1388 data
[0] = (u64
) xm_read32(hw
, port
, XM_TXO_OK_HI
) << 32
1389 | xm_read32(hw
, port
, XM_TXO_OK_LO
);
1390 data
[1] = (u64
) xm_read32(hw
, port
, XM_RXO_OK_HI
) << 32
1391 | xm_read32(hw
, port
, XM_RXO_OK_LO
);
1393 for (i
= 2; i
< ARRAY_SIZE(skge_stats
); i
++)
1394 data
[i
] = xm_read32(hw
, port
, skge_stats
[i
].xmac_offset
);
1397 static void genesis_mac_intr(struct skge_hw
*hw
, int port
)
1399 struct skge_port
*skge
= netdev_priv(hw
->dev
[port
]);
1400 u16 status
= xm_read16(hw
, port
, XM_ISRC
);
1402 if (netif_msg_intr(skge
))
1403 printk(KERN_DEBUG PFX
"%s: mac interrupt status 0x%x\n",
1404 skge
->netdev
->name
, status
);
1406 if (status
& XM_IS_TXF_UR
) {
1407 xm_write32(hw
, port
, XM_MODE
, XM_MD_FTF
);
1408 ++skge
->net_stats
.tx_fifo_errors
;
1410 if (status
& XM_IS_RXF_OV
) {
1411 xm_write32(hw
, port
, XM_MODE
, XM_MD_FRF
);
1412 ++skge
->net_stats
.rx_fifo_errors
;
1416 static void gm_phy_write(struct skge_hw
*hw
, int port
, u16 reg
, u16 val
)
1420 gma_write16(hw
, port
, GM_SMI_DATA
, val
);
1421 gma_write16(hw
, port
, GM_SMI_CTRL
,
1422 GM_SMI_CT_PHY_AD(hw
->phy_addr
) | GM_SMI_CT_REG_AD(reg
));
1423 for (i
= 0; i
< PHY_RETRIES
; i
++) {
1426 if (!(gma_read16(hw
, port
, GM_SMI_CTRL
) & GM_SMI_CT_BUSY
))
1431 static u16
gm_phy_read(struct skge_hw
*hw
, int port
, u16 reg
)
1435 gma_write16(hw
, port
, GM_SMI_CTRL
,
1436 GM_SMI_CT_PHY_AD(hw
->phy_addr
)
1437 | GM_SMI_CT_REG_AD(reg
) | GM_SMI_CT_OP_RD
);
1439 for (i
= 0; i
< PHY_RETRIES
; i
++) {
1441 if (gma_read16(hw
, port
, GM_SMI_CTRL
) & GM_SMI_CT_RD_VAL
)
1445 printk(KERN_WARNING PFX
"%s: phy read timeout\n",
1446 hw
->dev
[port
]->name
);
1449 return gma_read16(hw
, port
, GM_SMI_DATA
);
1452 static void genesis_link_up(struct skge_port
*skge
)
1454 struct skge_hw
*hw
= skge
->hw
;
1455 int port
= skge
->port
;
1459 pr_debug("genesis_link_up\n");
1460 cmd
= xm_read16(hw
, port
, XM_MMU_CMD
);
1463 * enabling pause frame reception is required for 1000BT
1464 * because the XMAC is not reset if the link is going down
1466 if (skge
->flow_control
== FLOW_MODE_NONE
||
1467 skge
->flow_control
== FLOW_MODE_LOC_SEND
)
1468 /* Disable Pause Frame Reception */
1469 cmd
|= XM_MMU_IGN_PF
;
1471 /* Enable Pause Frame Reception */
1472 cmd
&= ~XM_MMU_IGN_PF
;
1474 xm_write16(hw
, port
, XM_MMU_CMD
, cmd
);
1476 mode
= xm_read32(hw
, port
, XM_MODE
);
1477 if (skge
->flow_control
== FLOW_MODE_SYMMETRIC
||
1478 skge
->flow_control
== FLOW_MODE_LOC_SEND
) {
1480 * Configure Pause Frame Generation
1481 * Use internal and external Pause Frame Generation.
1482 * Sending pause frames is edge triggered.
1483 * Send a Pause frame with the maximum pause time if
1484 * internal oder external FIFO full condition occurs.
1485 * Send a zero pause time frame to re-start transmission.
1487 /* XM_PAUSE_DA = '010000C28001' (default) */
1488 /* XM_MAC_PTIME = 0xffff (maximum) */
1489 /* remember this value is defined in big endian (!) */
1490 xm_write16(hw
, port
, XM_MAC_PTIME
, 0xffff);
1492 mode
|= XM_PAUSE_MODE
;
1493 skge_write16(hw
, SK_REG(port
, RX_MFF_CTRL1
), MFF_ENA_PAUSE
);
1496 * disable pause frame generation is required for 1000BT
1497 * because the XMAC is not reset if the link is going down
1499 /* Disable Pause Mode in Mode Register */
1500 mode
&= ~XM_PAUSE_MODE
;
1502 skge_write16(hw
, SK_REG(port
, RX_MFF_CTRL1
), MFF_DIS_PAUSE
);
1505 xm_write32(hw
, port
, XM_MODE
, mode
);
1508 /* disable GP0 interrupt bit for external Phy */
1509 msk
|= XM_IS_INP_ASS
;
1511 xm_write16(hw
, port
, XM_IMSK
, msk
);
1512 xm_read16(hw
, port
, XM_ISRC
);
1514 /* get MMU Command Reg. */
1515 cmd
= xm_read16(hw
, port
, XM_MMU_CMD
);
1516 if (skge
->duplex
== DUPLEX_FULL
)
1517 cmd
|= XM_MMU_GMII_FD
;
1520 * Workaround BCOM Errata (#10523) for all BCom Phys
1521 * Enable Power Management after link up
1523 xm_phy_write(hw
, port
, PHY_BCOM_AUX_CTRL
,
1524 xm_phy_read(hw
, port
, PHY_BCOM_AUX_CTRL
)
1525 & ~PHY_B_AC_DIS_PM
);
1526 xm_phy_write(hw
, port
, PHY_BCOM_INT_MASK
, PHY_B_DEF_MSK
);
1529 xm_write16(hw
, port
, XM_MMU_CMD
,
1530 cmd
| XM_MMU_ENA_RX
| XM_MMU_ENA_TX
);
1535 static inline void bcom_phy_intr(struct skge_port
*skge
)
1537 struct skge_hw
*hw
= skge
->hw
;
1538 int port
= skge
->port
;
1541 isrc
= xm_phy_read(hw
, port
, PHY_BCOM_INT_STAT
);
1542 if (netif_msg_intr(skge
))
1543 printk(KERN_DEBUG PFX
"%s: phy interrupt status 0x%x\n",
1544 skge
->netdev
->name
, isrc
);
1546 if (isrc
& PHY_B_IS_PSE
)
1547 printk(KERN_ERR PFX
"%s: uncorrectable pair swap error\n",
1548 hw
->dev
[port
]->name
);
1550 /* Workaround BCom Errata:
1551 * enable and disable loopback mode if "NO HCD" occurs.
1553 if (isrc
& PHY_B_IS_NO_HDCL
) {
1554 u16 ctrl
= xm_phy_read(hw
, port
, PHY_BCOM_CTRL
);
1555 xm_phy_write(hw
, port
, PHY_BCOM_CTRL
,
1556 ctrl
| PHY_CT_LOOP
);
1557 xm_phy_write(hw
, port
, PHY_BCOM_CTRL
,
1558 ctrl
& ~PHY_CT_LOOP
);
1561 if (isrc
& (PHY_B_IS_AN_PR
| PHY_B_IS_LST_CHANGE
))
1562 bcom_check_link(hw
, port
);
1566 /* Marvell Phy Initailization */
1567 static void yukon_init(struct skge_hw
*hw
, int port
)
1569 struct skge_port
*skge
= netdev_priv(hw
->dev
[port
]);
1570 u16 ctrl
, ct1000
, adv
;
1571 u16 ledctrl
, ledover
;
1573 pr_debug("yukon_init\n");
1574 if (skge
->autoneg
== AUTONEG_ENABLE
) {
1575 u16 ectrl
= gm_phy_read(hw
, port
, PHY_MARV_EXT_CTRL
);
1577 ectrl
&= ~(PHY_M_EC_M_DSC_MSK
| PHY_M_EC_S_DSC_MSK
|
1578 PHY_M_EC_MAC_S_MSK
);
1579 ectrl
|= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ
);
1581 ectrl
|= PHY_M_EC_M_DSC(0) | PHY_M_EC_S_DSC(1);
1583 gm_phy_write(hw
, port
, PHY_MARV_EXT_CTRL
, ectrl
);
1586 ctrl
= gm_phy_read(hw
, port
, PHY_MARV_CTRL
);
1587 if (skge
->autoneg
== AUTONEG_DISABLE
)
1588 ctrl
&= ~PHY_CT_ANE
;
1590 ctrl
|= PHY_CT_RESET
;
1591 gm_phy_write(hw
, port
, PHY_MARV_CTRL
, ctrl
);
1597 if (skge
->autoneg
== AUTONEG_ENABLE
) {
1599 if (skge
->advertising
& ADVERTISED_1000baseT_Full
)
1600 ct1000
|= PHY_M_1000C_AFD
;
1601 if (skge
->advertising
& ADVERTISED_1000baseT_Half
)
1602 ct1000
|= PHY_M_1000C_AHD
;
1603 if (skge
->advertising
& ADVERTISED_100baseT_Full
)
1604 adv
|= PHY_M_AN_100_FD
;
1605 if (skge
->advertising
& ADVERTISED_100baseT_Half
)
1606 adv
|= PHY_M_AN_100_HD
;
1607 if (skge
->advertising
& ADVERTISED_10baseT_Full
)
1608 adv
|= PHY_M_AN_10_FD
;
1609 if (skge
->advertising
& ADVERTISED_10baseT_Half
)
1610 adv
|= PHY_M_AN_10_HD
;
1611 } else /* special defines for FIBER (88E1011S only) */
1612 adv
|= PHY_M_AN_1000X_AHD
| PHY_M_AN_1000X_AFD
;
1614 /* Set Flow-control capabilities */
1615 adv
|= phy_pause_map
[skge
->flow_control
];
1617 /* Restart Auto-negotiation */
1618 ctrl
|= PHY_CT_ANE
| PHY_CT_RE_CFG
;
1620 /* forced speed/duplex settings */
1621 ct1000
= PHY_M_1000C_MSE
;
1623 if (skge
->duplex
== DUPLEX_FULL
)
1624 ctrl
|= PHY_CT_DUP_MD
;
1626 switch (skge
->speed
) {
1628 ctrl
|= PHY_CT_SP1000
;
1631 ctrl
|= PHY_CT_SP100
;
1635 ctrl
|= PHY_CT_RESET
;
1638 gm_phy_write(hw
, port
, PHY_MARV_1000T_CTRL
, ct1000
);
1640 gm_phy_write(hw
, port
, PHY_MARV_AUNE_ADV
, adv
);
1641 gm_phy_write(hw
, port
, PHY_MARV_CTRL
, ctrl
);
1643 /* Setup Phy LED's */
1644 ledctrl
= PHY_M_LED_PULS_DUR(PULS_170MS
);
1647 ledctrl
|= PHY_M_LED_BLINK_RT(BLINK_84MS
) | PHY_M_LEDC_TX_CTRL
;
1649 /* turn off the Rx LED (LED_RX) */
1650 ledover
|= PHY_M_LED_MO_RX(MO_LED_OFF
);
1652 /* disable blink mode (LED_DUPLEX) on collisions */
1653 ctrl
|= PHY_M_LEDC_DP_CTRL
;
1654 gm_phy_write(hw
, port
, PHY_MARV_LED_CTRL
, ledctrl
);
1656 if (skge
->autoneg
== AUTONEG_DISABLE
|| skge
->speed
== SPEED_100
) {
1657 /* turn on 100 Mbps LED (LED_LINK100) */
1658 ledover
|= PHY_M_LED_MO_100(MO_LED_ON
);
1662 gm_phy_write(hw
, port
, PHY_MARV_LED_OVER
, ledover
);
1664 /* Enable phy interrupt on autonegotiation complete (or link up) */
1665 if (skge
->autoneg
== AUTONEG_ENABLE
)
1666 gm_phy_write(hw
, port
, PHY_MARV_INT_MASK
, PHY_M_IS_AN_COMPL
);
1668 gm_phy_write(hw
, port
, PHY_MARV_INT_MASK
, PHY_M_DEF_MSK
);
1671 static void yukon_reset(struct skge_hw
*hw
, int port
)
1673 gm_phy_write(hw
, port
, PHY_MARV_INT_MASK
, 0);/* disable PHY IRQs */
1674 gma_write16(hw
, port
, GM_MC_ADDR_H1
, 0); /* clear MC hash */
1675 gma_write16(hw
, port
, GM_MC_ADDR_H2
, 0);
1676 gma_write16(hw
, port
, GM_MC_ADDR_H3
, 0);
1677 gma_write16(hw
, port
, GM_MC_ADDR_H4
, 0);
1679 gma_write16(hw
, port
, GM_RX_CTRL
,
1680 gma_read16(hw
, port
, GM_RX_CTRL
)
1681 | GM_RXCR_UCF_ENA
| GM_RXCR_MCF_ENA
);
1684 static void yukon_mac_init(struct skge_hw
*hw
, int port
)
1686 struct skge_port
*skge
= netdev_priv(hw
->dev
[port
]);
1689 const u8
*addr
= hw
->dev
[port
]->dev_addr
;
1691 /* WA code for COMA mode -- set PHY reset */
1692 if (hw
->chip_id
== CHIP_ID_YUKON_LITE
&&
1693 hw
->chip_rev
== CHIP_REV_YU_LITE_A3
)
1694 skge_write32(hw
, B2_GP_IO
,
1695 (skge_read32(hw
, B2_GP_IO
) | GP_DIR_9
| GP_IO_9
));
1698 skge_write32(hw
, SK_REG(port
, GPHY_CTRL
), GPC_RST_SET
);
1699 skge_write32(hw
, SK_REG(port
, GMAC_CTRL
), GMC_RST_SET
);
1701 /* WA code for COMA mode -- clear PHY reset */
1702 if (hw
->chip_id
== CHIP_ID_YUKON_LITE
&&
1703 hw
->chip_rev
== CHIP_REV_YU_LITE_A3
)
1704 skge_write32(hw
, B2_GP_IO
,
1705 (skge_read32(hw
, B2_GP_IO
) | GP_DIR_9
)
1708 /* Set hardware config mode */
1709 reg
= GPC_INT_POL_HI
| GPC_DIS_FC
| GPC_DIS_SLEEP
|
1710 GPC_ENA_XC
| GPC_ANEG_ADV_ALL_M
| GPC_ENA_PAUSE
;
1711 reg
|= iscopper(hw
) ? GPC_HWCFG_GMII_COP
: GPC_HWCFG_GMII_FIB
;
1713 /* Clear GMC reset */
1714 skge_write32(hw
, SK_REG(port
, GPHY_CTRL
), reg
| GPC_RST_SET
);
1715 skge_write32(hw
, SK_REG(port
, GPHY_CTRL
), reg
| GPC_RST_CLR
);
1716 skge_write32(hw
, SK_REG(port
, GMAC_CTRL
), GMC_PAUSE_ON
| GMC_RST_CLR
);
1717 if (skge
->autoneg
== AUTONEG_DISABLE
) {
1718 reg
= GM_GPCR_AU_ALL_DIS
;
1719 gma_write16(hw
, port
, GM_GP_CTRL
,
1720 gma_read16(hw
, port
, GM_GP_CTRL
) | reg
);
1722 switch (skge
->speed
) {
1724 reg
|= GM_GPCR_SPEED_1000
;
1727 reg
|= GM_GPCR_SPEED_100
;
1730 if (skge
->duplex
== DUPLEX_FULL
)
1731 reg
|= GM_GPCR_DUP_FULL
;
1733 reg
= GM_GPCR_SPEED_1000
| GM_GPCR_SPEED_100
| GM_GPCR_DUP_FULL
;
1734 switch (skge
->flow_control
) {
1735 case FLOW_MODE_NONE
:
1736 skge_write32(hw
, SK_REG(port
, GMAC_CTRL
), GMC_PAUSE_OFF
);
1737 reg
|= GM_GPCR_FC_TX_DIS
| GM_GPCR_FC_RX_DIS
| GM_GPCR_AU_FCT_DIS
;
1739 case FLOW_MODE_LOC_SEND
:
1740 /* disable Rx flow-control */
1741 reg
|= GM_GPCR_FC_RX_DIS
| GM_GPCR_AU_FCT_DIS
;
1744 gma_write16(hw
, port
, GM_GP_CTRL
, reg
);
1745 skge_read16(hw
, GMAC_IRQ_SRC
);
1747 spin_lock_bh(&hw
->phy_lock
);
1748 yukon_init(hw
, port
);
1749 spin_unlock_bh(&hw
->phy_lock
);
1752 reg
= gma_read16(hw
, port
, GM_PHY_ADDR
);
1753 gma_write16(hw
, port
, GM_PHY_ADDR
, reg
| GM_PAR_MIB_CLR
);
1755 for (i
= 0; i
< GM_MIB_CNT_SIZE
; i
++)
1756 gma_read16(hw
, port
, GM_MIB_CNT_BASE
+ 8*i
);
1757 gma_write16(hw
, port
, GM_PHY_ADDR
, reg
);
1759 /* transmit control */
1760 gma_write16(hw
, port
, GM_TX_CTRL
, TX_COL_THR(TX_COL_DEF
));
1762 /* receive control reg: unicast + multicast + no FCS */
1763 gma_write16(hw
, port
, GM_RX_CTRL
,
1764 GM_RXCR_UCF_ENA
| GM_RXCR_CRC_DIS
| GM_RXCR_MCF_ENA
);
1766 /* transmit flow control */
1767 gma_write16(hw
, port
, GM_TX_FLOW_CTRL
, 0xffff);
1769 /* transmit parameter */
1770 gma_write16(hw
, port
, GM_TX_PARAM
,
1771 TX_JAM_LEN_VAL(TX_JAM_LEN_DEF
) |
1772 TX_JAM_IPG_VAL(TX_JAM_IPG_DEF
) |
1773 TX_IPG_JAM_DATA(TX_IPG_JAM_DEF
));
1775 /* serial mode register */
1776 reg
= GM_SMOD_VLAN_ENA
| IPG_DATA_VAL(IPG_DATA_DEF
);
1777 if (hw
->dev
[port
]->mtu
> 1500)
1778 reg
|= GM_SMOD_JUMBO_ENA
;
1780 gma_write16(hw
, port
, GM_SERIAL_MODE
, reg
);
1782 /* physical address: used for pause frames */
1783 gma_set_addr(hw
, port
, GM_SRC_ADDR_1L
, addr
);
1784 /* virtual address for data */
1785 gma_set_addr(hw
, port
, GM_SRC_ADDR_2L
, addr
);
1787 /* enable interrupt mask for counter overflows */
1788 gma_write16(hw
, port
, GM_TX_IRQ_MSK
, 0);
1789 gma_write16(hw
, port
, GM_RX_IRQ_MSK
, 0);
1790 gma_write16(hw
, port
, GM_TR_IRQ_MSK
, 0);
1792 /* Initialize Mac Fifo */
1794 /* Configure Rx MAC FIFO */
1795 skge_write16(hw
, SK_REG(port
, RX_GMF_FL_MSK
), RX_FF_FL_DEF_MSK
);
1796 reg
= GMF_OPER_ON
| GMF_RX_F_FL_ON
;
1797 if (hw
->chip_id
== CHIP_ID_YUKON_LITE
&&
1798 hw
->chip_rev
== CHIP_REV_YU_LITE_A3
)
1799 reg
&= ~GMF_RX_F_FL_ON
;
1800 skge_write8(hw
, SK_REG(port
, RX_GMF_CTRL_T
), GMF_RST_CLR
);
1801 skge_write16(hw
, SK_REG(port
, RX_GMF_CTRL_T
), reg
);
1802 skge_write16(hw
, SK_REG(port
, RX_GMF_FL_THR
), RX_GMF_FL_THR_DEF
);
1804 /* Configure Tx MAC FIFO */
1805 skge_write8(hw
, SK_REG(port
, TX_GMF_CTRL_T
), GMF_RST_CLR
);
1806 skge_write16(hw
, SK_REG(port
, TX_GMF_CTRL_T
), GMF_OPER_ON
);
1809 static void yukon_stop(struct skge_port
*skge
)
1811 struct skge_hw
*hw
= skge
->hw
;
1812 int port
= skge
->port
;
1814 if (hw
->chip_id
== CHIP_ID_YUKON_LITE
&&
1815 hw
->chip_rev
== CHIP_REV_YU_LITE_A3
) {
1816 skge_write32(hw
, B2_GP_IO
,
1817 skge_read32(hw
, B2_GP_IO
) | GP_DIR_9
| GP_IO_9
);
1820 gma_write16(hw
, port
, GM_GP_CTRL
,
1821 gma_read16(hw
, port
, GM_GP_CTRL
)
1822 & ~(GM_GPCR_TX_ENA
|GM_GPCR_RX_ENA
));
1823 gma_read16(hw
, port
, GM_GP_CTRL
);
1825 /* set GPHY Control reset */
1826 gma_write32(hw
, port
, GPHY_CTRL
, GPC_RST_SET
);
1827 gma_write32(hw
, port
, GMAC_CTRL
, GMC_RST_SET
);
1830 static void yukon_get_stats(struct skge_port
*skge
, u64
*data
)
1832 struct skge_hw
*hw
= skge
->hw
;
1833 int port
= skge
->port
;
1836 data
[0] = (u64
) gma_read32(hw
, port
, GM_TXO_OK_HI
) << 32
1837 | gma_read32(hw
, port
, GM_TXO_OK_LO
);
1838 data
[1] = (u64
) gma_read32(hw
, port
, GM_RXO_OK_HI
) << 32
1839 | gma_read32(hw
, port
, GM_RXO_OK_LO
);
1841 for (i
= 2; i
< ARRAY_SIZE(skge_stats
); i
++)
1842 data
[i
] = gma_read32(hw
, port
,
1843 skge_stats
[i
].gma_offset
);
1846 static void yukon_mac_intr(struct skge_hw
*hw
, int port
)
1848 struct net_device
*dev
= hw
->dev
[port
];
1849 struct skge_port
*skge
= netdev_priv(dev
);
1850 u8 status
= skge_read8(hw
, SK_REG(port
, GMAC_IRQ_SRC
));
1852 if (netif_msg_intr(skge
))
1853 printk(KERN_DEBUG PFX
"%s: mac interrupt status 0x%x\n",
1856 if (status
& GM_IS_RX_FF_OR
) {
1857 ++skge
->net_stats
.rx_fifo_errors
;
1858 gma_write8(hw
, port
, RX_GMF_CTRL_T
, GMF_CLI_RX_FO
);
1860 if (status
& GM_IS_TX_FF_UR
) {
1861 ++skge
->net_stats
.tx_fifo_errors
;
1862 gma_write8(hw
, port
, TX_GMF_CTRL_T
, GMF_CLI_TX_FU
);
1867 static u16
yukon_speed(const struct skge_hw
*hw
, u16 aux
)
1869 switch (aux
& PHY_M_PS_SPEED_MSK
) {
1870 case PHY_M_PS_SPEED_1000
:
1872 case PHY_M_PS_SPEED_100
:
1879 static void yukon_link_up(struct skge_port
*skge
)
1881 struct skge_hw
*hw
= skge
->hw
;
1882 int port
= skge
->port
;
1885 pr_debug("yukon_link_up\n");
1887 /* Enable Transmit FIFO Underrun */
1888 skge_write8(hw
, GMAC_IRQ_MSK
, GMAC_DEF_MSK
);
1890 reg
= gma_read16(hw
, port
, GM_GP_CTRL
);
1891 if (skge
->duplex
== DUPLEX_FULL
|| skge
->autoneg
== AUTONEG_ENABLE
)
1892 reg
|= GM_GPCR_DUP_FULL
;
1895 reg
|= GM_GPCR_RX_ENA
| GM_GPCR_TX_ENA
;
1896 gma_write16(hw
, port
, GM_GP_CTRL
, reg
);
1898 gm_phy_write(hw
, port
, PHY_MARV_INT_MASK
, PHY_M_DEF_MSK
);
1902 static void yukon_link_down(struct skge_port
*skge
)
1904 struct skge_hw
*hw
= skge
->hw
;
1905 int port
= skge
->port
;
1907 pr_debug("yukon_link_down\n");
1908 gm_phy_write(hw
, port
, PHY_MARV_INT_MASK
, 0);
1909 gm_phy_write(hw
, port
, GM_GP_CTRL
,
1910 gm_phy_read(hw
, port
, GM_GP_CTRL
)
1911 & ~(GM_GPCR_RX_ENA
| GM_GPCR_TX_ENA
));
1913 if (skge
->flow_control
== FLOW_MODE_REM_SEND
) {
1914 /* restore Asymmetric Pause bit */
1915 gm_phy_write(hw
, port
, PHY_MARV_AUNE_ADV
,
1916 gm_phy_read(hw
, port
,
1922 yukon_reset(hw
, port
);
1923 skge_link_down(skge
);
1925 yukon_init(hw
, port
);
1928 static void yukon_phy_intr(struct skge_port
*skge
)
1930 struct skge_hw
*hw
= skge
->hw
;
1931 int port
= skge
->port
;
1932 const char *reason
= NULL
;
1933 u16 istatus
, phystat
;
1935 istatus
= gm_phy_read(hw
, port
, PHY_MARV_INT_STAT
);
1936 phystat
= gm_phy_read(hw
, port
, PHY_MARV_PHY_STAT
);
1938 if (netif_msg_intr(skge
))
1939 printk(KERN_DEBUG PFX
"%s: phy interrupt status 0x%x 0x%x\n",
1940 skge
->netdev
->name
, istatus
, phystat
);
1942 if (istatus
& PHY_M_IS_AN_COMPL
) {
1943 if (gm_phy_read(hw
, port
, PHY_MARV_AUNE_LP
)
1945 reason
= "remote fault";
1949 if (gm_phy_read(hw
, port
, PHY_MARV_1000T_STAT
) & PHY_B_1000S_MSF
) {
1950 reason
= "master/slave fault";
1954 if (!(phystat
& PHY_M_PS_SPDUP_RES
)) {
1955 reason
= "speed/duplex";
1959 skge
->duplex
= (phystat
& PHY_M_PS_FULL_DUP
)
1960 ? DUPLEX_FULL
: DUPLEX_HALF
;
1961 skge
->speed
= yukon_speed(hw
, phystat
);
1963 /* We are using IEEE 802.3z/D5.0 Table 37-4 */
1964 switch (phystat
& PHY_M_PS_PAUSE_MSK
) {
1965 case PHY_M_PS_PAUSE_MSK
:
1966 skge
->flow_control
= FLOW_MODE_SYMMETRIC
;
1968 case PHY_M_PS_RX_P_EN
:
1969 skge
->flow_control
= FLOW_MODE_REM_SEND
;
1971 case PHY_M_PS_TX_P_EN
:
1972 skge
->flow_control
= FLOW_MODE_LOC_SEND
;
1975 skge
->flow_control
= FLOW_MODE_NONE
;
1978 if (skge
->flow_control
== FLOW_MODE_NONE
||
1979 (skge
->speed
< SPEED_1000
&& skge
->duplex
== DUPLEX_HALF
))
1980 skge_write8(hw
, SK_REG(port
, GMAC_CTRL
), GMC_PAUSE_OFF
);
1982 skge_write8(hw
, SK_REG(port
, GMAC_CTRL
), GMC_PAUSE_ON
);
1983 yukon_link_up(skge
);
1987 if (istatus
& PHY_M_IS_LSP_CHANGE
)
1988 skge
->speed
= yukon_speed(hw
, phystat
);
1990 if (istatus
& PHY_M_IS_DUP_CHANGE
)
1991 skge
->duplex
= (phystat
& PHY_M_PS_FULL_DUP
) ? DUPLEX_FULL
: DUPLEX_HALF
;
1992 if (istatus
& PHY_M_IS_LST_CHANGE
) {
1993 if (phystat
& PHY_M_PS_LINK_UP
)
1994 yukon_link_up(skge
);
1996 yukon_link_down(skge
);
2000 printk(KERN_ERR PFX
"%s: autonegotiation failed (%s)\n",
2001 skge
->netdev
->name
, reason
);
2003 /* XXX restart autonegotiation? */
2006 static void skge_ramset(struct skge_hw
*hw
, u16 q
, u32 start
, size_t len
)
2012 end
= start
+ len
- 1;
2014 skge_write8(hw
, RB_ADDR(q
, RB_CTRL
), RB_RST_CLR
);
2015 skge_write32(hw
, RB_ADDR(q
, RB_START
), start
);
2016 skge_write32(hw
, RB_ADDR(q
, RB_WP
), start
);
2017 skge_write32(hw
, RB_ADDR(q
, RB_RP
), start
);
2018 skge_write32(hw
, RB_ADDR(q
, RB_END
), end
);
2020 if (q
== Q_R1
|| q
== Q_R2
) {
2021 /* Set thresholds on receive queue's */
2022 skge_write32(hw
, RB_ADDR(q
, RB_RX_UTPP
),
2024 skge_write32(hw
, RB_ADDR(q
, RB_RX_LTPP
),
2027 /* Enable store & forward on Tx queue's because
2028 * Tx FIFO is only 4K on Genesis and 1K on Yukon
2030 skge_write8(hw
, RB_ADDR(q
, RB_CTRL
), RB_ENA_STFWD
);
2033 skge_write8(hw
, RB_ADDR(q
, RB_CTRL
), RB_ENA_OP_MD
);
2036 /* Setup Bus Memory Interface */
2037 static void skge_qset(struct skge_port
*skge
, u16 q
,
2038 const struct skge_element
*e
)
2040 struct skge_hw
*hw
= skge
->hw
;
2041 u32 watermark
= 0x600;
2042 u64 base
= skge
->dma
+ (e
->desc
- skge
->mem
);
2044 /* optimization to reduce window on 32bit/33mhz */
2045 if ((skge_read16(hw
, B0_CTST
) & (CS_BUS_CLOCK
| CS_BUS_SLOT_SZ
)) == 0)
2048 skge_write32(hw
, Q_ADDR(q
, Q_CSR
), CSR_CLR_RESET
);
2049 skge_write32(hw
, Q_ADDR(q
, Q_F
), watermark
);
2050 skge_write32(hw
, Q_ADDR(q
, Q_DA_H
), (u32
)(base
>> 32));
2051 skge_write32(hw
, Q_ADDR(q
, Q_DA_L
), (u32
)base
);
2054 static int skge_up(struct net_device
*dev
)
2056 struct skge_port
*skge
= netdev_priv(dev
);
2057 struct skge_hw
*hw
= skge
->hw
;
2058 int port
= skge
->port
;
2059 u32 chunk
, ram_addr
;
2060 size_t rx_size
, tx_size
;
2063 if (netif_msg_ifup(skge
))
2064 printk(KERN_INFO PFX
"%s: enabling interface\n", dev
->name
);
2066 if (dev
->mtu
> RX_BUF_SIZE
)
2067 skge
->rx_buf_size
= dev
->mtu
+ ETH_HLEN
+ NET_IP_ALIGN
;
2069 skge
->rx_buf_size
= RX_BUF_SIZE
;
2072 rx_size
= skge
->rx_ring
.count
* sizeof(struct skge_rx_desc
);
2073 tx_size
= skge
->tx_ring
.count
* sizeof(struct skge_tx_desc
);
2074 skge
->mem_size
= tx_size
+ rx_size
;
2075 skge
->mem
= pci_alloc_consistent(hw
->pdev
, skge
->mem_size
, &skge
->dma
);
2079 memset(skge
->mem
, 0, skge
->mem_size
);
2081 if ((err
= skge_ring_alloc(&skge
->rx_ring
, skge
->mem
, skge
->dma
)))
2084 err
= skge_rx_fill(skge
);
2088 if ((err
= skge_ring_alloc(&skge
->tx_ring
, skge
->mem
+ rx_size
,
2089 skge
->dma
+ rx_size
)))
2092 skge
->tx_avail
= skge
->tx_ring
.count
- 1;
2094 /* Enable IRQ from port */
2095 hw
->intr_mask
|= portirqmask
[port
];
2096 skge_write32(hw
, B0_IMSK
, hw
->intr_mask
);
2099 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2100 genesis_mac_init(hw
, port
);
2102 yukon_mac_init(hw
, port
);
2104 /* Configure RAMbuffers */
2105 chunk
= hw
->ram_size
/ ((hw
->ports
+ 1)*2);
2106 ram_addr
= hw
->ram_offset
+ 2 * chunk
* port
;
2108 skge_ramset(hw
, rxqaddr
[port
], ram_addr
, chunk
);
2109 skge_qset(skge
, rxqaddr
[port
], skge
->rx_ring
.to_clean
);
2111 BUG_ON(skge
->tx_ring
.to_use
!= skge
->tx_ring
.to_clean
);
2112 skge_ramset(hw
, txqaddr
[port
], ram_addr
+chunk
, chunk
);
2113 skge_qset(skge
, txqaddr
[port
], skge
->tx_ring
.to_use
);
2115 /* Start receiver BMU */
2117 skge_write8(hw
, Q_ADDR(rxqaddr
[port
], Q_CSR
), CSR_START
| CSR_IRQ_CL_F
);
2119 pr_debug("skge_up completed\n");
2123 skge_rx_clean(skge
);
2124 kfree(skge
->rx_ring
.start
);
2126 pci_free_consistent(hw
->pdev
, skge
->mem_size
, skge
->mem
, skge
->dma
);
2131 static int skge_down(struct net_device
*dev
)
2133 struct skge_port
*skge
= netdev_priv(dev
);
2134 struct skge_hw
*hw
= skge
->hw
;
2135 int port
= skge
->port
;
2137 if (netif_msg_ifdown(skge
))
2138 printk(KERN_INFO PFX
"%s: disabling interface\n", dev
->name
);
2140 netif_stop_queue(dev
);
2142 del_timer_sync(&skge
->led_blink
);
2144 /* Stop transmitter */
2145 skge_write8(hw
, Q_ADDR(txqaddr
[port
], Q_CSR
), CSR_STOP
);
2146 skge_write32(hw
, RB_ADDR(txqaddr
[port
], RB_CTRL
),
2147 RB_RST_SET
|RB_DIS_OP_MD
);
2149 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2154 /* Disable Force Sync bit and Enable Alloc bit */
2155 skge_write8(hw
, SK_REG(port
, TXA_CTRL
),
2156 TXA_DIS_FSYNC
| TXA_DIS_ALLOC
| TXA_STOP_RC
);
2158 /* Stop Interval Timer and Limit Counter of Tx Arbiter */
2159 skge_write32(hw
, SK_REG(port
, TXA_ITI_INI
), 0L);
2160 skge_write32(hw
, SK_REG(port
, TXA_LIM_INI
), 0L);
2162 /* Reset PCI FIFO */
2163 skge_write32(hw
, Q_ADDR(txqaddr
[port
], Q_CSR
), CSR_SET_RESET
);
2164 skge_write32(hw
, RB_ADDR(txqaddr
[port
], RB_CTRL
), RB_RST_SET
);
2166 /* Reset the RAM Buffer async Tx queue */
2167 skge_write8(hw
, RB_ADDR(port
== 0 ? Q_XA1
: Q_XA2
, RB_CTRL
), RB_RST_SET
);
2169 skge_write8(hw
, Q_ADDR(rxqaddr
[port
], Q_CSR
), CSR_STOP
);
2170 skge_write32(hw
, RB_ADDR(port
? Q_R2
: Q_R1
, RB_CTRL
),
2171 RB_RST_SET
|RB_DIS_OP_MD
);
2172 skge_write32(hw
, Q_ADDR(rxqaddr
[port
], Q_CSR
), CSR_SET_RESET
);
2174 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
2175 skge_write8(hw
, SK_REG(port
, TX_MFF_CTRL2
), MFF_RST_SET
);
2176 skge_write8(hw
, SK_REG(port
, RX_MFF_CTRL2
), MFF_RST_SET
);
2177 skge_write8(hw
, SK_REG(port
, TX_LED_CTRL
), LED_STOP
);
2178 skge_write8(hw
, SK_REG(port
, RX_LED_CTRL
), LED_STOP
);
2180 skge_write8(hw
, SK_REG(port
, RX_GMF_CTRL_T
), GMF_RST_SET
);
2181 skge_write8(hw
, SK_REG(port
, TX_GMF_CTRL_T
), GMF_RST_SET
);
2184 /* turn off led's */
2185 skge_write16(hw
, B0_LED
, LED_STAT_OFF
);
2187 skge_tx_clean(skge
);
2188 skge_rx_clean(skge
);
2190 kfree(skge
->rx_ring
.start
);
2191 kfree(skge
->tx_ring
.start
);
2192 pci_free_consistent(hw
->pdev
, skge
->mem_size
, skge
->mem
, skge
->dma
);
2196 static int skge_xmit_frame(struct sk_buff
*skb
, struct net_device
*dev
)
2198 struct skge_port
*skge
= netdev_priv(dev
);
2199 struct skge_hw
*hw
= skge
->hw
;
2200 struct skge_ring
*ring
= &skge
->tx_ring
;
2201 struct skge_element
*e
;
2202 struct skge_tx_desc
*td
;
2206 unsigned long flags
;
2208 skb
= skb_padto(skb
, ETH_ZLEN
);
2210 return NETDEV_TX_OK
;
2212 local_irq_save(flags
);
2213 if (!spin_trylock(&skge
->tx_lock
)) {
2214 /* Collision - tell upper layer to requeue */
2215 local_irq_restore(flags
);
2216 return NETDEV_TX_LOCKED
;
2219 if (unlikely(skge
->tx_avail
< skb_shinfo(skb
)->nr_frags
+1)) {
2220 netif_stop_queue(dev
);
2221 spin_unlock_irqrestore(&skge
->tx_lock
, flags
);
2223 printk(KERN_WARNING PFX
"%s: ring full when queue awake!\n",
2225 return NETDEV_TX_BUSY
;
2231 len
= skb_headlen(skb
);
2232 map
= pci_map_single(hw
->pdev
, skb
->data
, len
, PCI_DMA_TODEVICE
);
2233 pci_unmap_addr_set(e
, mapaddr
, map
);
2234 pci_unmap_len_set(e
, maplen
, len
);
2237 td
->dma_hi
= map
>> 32;
2239 if (skb
->ip_summed
== CHECKSUM_HW
) {
2240 const struct iphdr
*ip
2241 = (const struct iphdr
*) (skb
->data
+ ETH_HLEN
);
2242 int offset
= skb
->h
.raw
- skb
->data
;
2244 /* This seems backwards, but it is what the sk98lin
2245 * does. Looks like hardware is wrong?
2247 if (ip
->protocol
== IPPROTO_UDP
2248 && hw
->chip_rev
== 0 && hw
->chip_id
== CHIP_ID_YUKON
)
2249 control
= BMU_TCP_CHECK
;
2251 control
= BMU_UDP_CHECK
;
2254 td
->csum_start
= offset
;
2255 td
->csum_write
= offset
+ skb
->csum
;
2257 control
= BMU_CHECK
;
2259 if (!skb_shinfo(skb
)->nr_frags
) /* single buffer i.e. no fragments */
2260 control
|= BMU_EOF
| BMU_IRQ_EOF
;
2262 struct skge_tx_desc
*tf
= td
;
2264 control
|= BMU_STFWD
;
2265 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
2266 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
2268 map
= pci_map_page(hw
->pdev
, frag
->page
, frag
->page_offset
,
2269 frag
->size
, PCI_DMA_TODEVICE
);
2275 tf
->dma_hi
= (u64
) map
>> 32;
2276 pci_unmap_addr_set(e
, mapaddr
, map
);
2277 pci_unmap_len_set(e
, maplen
, frag
->size
);
2279 tf
->control
= BMU_OWN
| BMU_SW
| control
| frag
->size
;
2281 tf
->control
|= BMU_EOF
| BMU_IRQ_EOF
;
2283 /* Make sure all the descriptors written */
2285 td
->control
= BMU_OWN
| BMU_SW
| BMU_STF
| control
| len
;
2288 skge_write8(hw
, Q_ADDR(txqaddr
[skge
->port
], Q_CSR
), CSR_START
);
2290 if (netif_msg_tx_queued(skge
))
2291 printk(KERN_DEBUG
"%s: tx queued, slot %td, len %d\n",
2292 dev
->name
, e
- ring
->start
, skb
->len
);
2294 ring
->to_use
= e
->next
;
2295 skge
->tx_avail
-= skb_shinfo(skb
)->nr_frags
+ 1;
2296 if (skge
->tx_avail
<= MAX_SKB_FRAGS
+ 1) {
2297 pr_debug("%s: transmit queue full\n", dev
->name
);
2298 netif_stop_queue(dev
);
2301 dev
->trans_start
= jiffies
;
2302 spin_unlock_irqrestore(&skge
->tx_lock
, flags
);
2304 return NETDEV_TX_OK
;
2307 static inline void skge_tx_free(struct skge_hw
*hw
, struct skge_element
*e
)
2309 /* This ring element can be skb or fragment */
2311 pci_unmap_single(hw
->pdev
,
2312 pci_unmap_addr(e
, mapaddr
),
2313 pci_unmap_len(e
, maplen
),
2315 dev_kfree_skb_any(e
->skb
);
2318 pci_unmap_page(hw
->pdev
,
2319 pci_unmap_addr(e
, mapaddr
),
2320 pci_unmap_len(e
, maplen
),
2325 static void skge_tx_clean(struct skge_port
*skge
)
2327 struct skge_ring
*ring
= &skge
->tx_ring
;
2328 struct skge_element
*e
;
2329 unsigned long flags
;
2331 spin_lock_irqsave(&skge
->tx_lock
, flags
);
2332 for (e
= ring
->to_clean
; e
!= ring
->to_use
; e
= e
->next
) {
2334 skge_tx_free(skge
->hw
, e
);
2337 spin_unlock_irqrestore(&skge
->tx_lock
, flags
);
2340 static void skge_tx_timeout(struct net_device
*dev
)
2342 struct skge_port
*skge
= netdev_priv(dev
);
2344 if (netif_msg_timer(skge
))
2345 printk(KERN_DEBUG PFX
"%s: tx timeout\n", dev
->name
);
2347 skge_write8(skge
->hw
, Q_ADDR(txqaddr
[skge
->port
], Q_CSR
), CSR_STOP
);
2348 skge_tx_clean(skge
);
2351 static int skge_change_mtu(struct net_device
*dev
, int new_mtu
)
2354 int running
= netif_running(dev
);
2356 if (new_mtu
< ETH_ZLEN
|| new_mtu
> ETH_JUMBO_MTU
)
2369 static void genesis_set_multicast(struct net_device
*dev
)
2371 struct skge_port
*skge
= netdev_priv(dev
);
2372 struct skge_hw
*hw
= skge
->hw
;
2373 int port
= skge
->port
;
2374 int i
, count
= dev
->mc_count
;
2375 struct dev_mc_list
*list
= dev
->mc_list
;
2379 pr_debug("genesis_set_multicast flags=%x count=%d\n", dev
->flags
, dev
->mc_count
);
2381 mode
= xm_read32(hw
, port
, XM_MODE
);
2382 mode
|= XM_MD_ENA_HASH
;
2383 if (dev
->flags
& IFF_PROMISC
)
2384 mode
|= XM_MD_ENA_PROM
;
2386 mode
&= ~XM_MD_ENA_PROM
;
2388 if (dev
->flags
& IFF_ALLMULTI
)
2389 memset(filter
, 0xff, sizeof(filter
));
2391 memset(filter
, 0, sizeof(filter
));
2392 for (i
= 0; list
&& i
< count
; i
++, list
= list
->next
) {
2394 crc
= ether_crc_le(ETH_ALEN
, list
->dmi_addr
);
2396 filter
[bit
/8] |= 1 << (bit
%8);
2400 xm_write32(hw
, port
, XM_MODE
, mode
);
2401 xm_outhash(hw
, port
, XM_HSM
, filter
);
2404 static void yukon_set_multicast(struct net_device
*dev
)
2406 struct skge_port
*skge
= netdev_priv(dev
);
2407 struct skge_hw
*hw
= skge
->hw
;
2408 int port
= skge
->port
;
2409 struct dev_mc_list
*list
= dev
->mc_list
;
2413 memset(filter
, 0, sizeof(filter
));
2415 reg
= gma_read16(hw
, port
, GM_RX_CTRL
);
2416 reg
|= GM_RXCR_UCF_ENA
;
2418 if (dev
->flags
& IFF_PROMISC
) /* promiscious */
2419 reg
&= ~(GM_RXCR_UCF_ENA
| GM_RXCR_MCF_ENA
);
2420 else if (dev
->flags
& IFF_ALLMULTI
) /* all multicast */
2421 memset(filter
, 0xff, sizeof(filter
));
2422 else if (dev
->mc_count
== 0) /* no multicast */
2423 reg
&= ~GM_RXCR_MCF_ENA
;
2426 reg
|= GM_RXCR_MCF_ENA
;
2428 for (i
= 0; list
&& i
< dev
->mc_count
; i
++, list
= list
->next
) {
2429 u32 bit
= ether_crc(ETH_ALEN
, list
->dmi_addr
) & 0x3f;
2430 filter
[bit
/8] |= 1 << (bit
%8);
2435 gma_write16(hw
, port
, GM_MC_ADDR_H1
,
2436 (u16
)filter
[0] | ((u16
)filter
[1] << 8));
2437 gma_write16(hw
, port
, GM_MC_ADDR_H2
,
2438 (u16
)filter
[2] | ((u16
)filter
[3] << 8));
2439 gma_write16(hw
, port
, GM_MC_ADDR_H3
,
2440 (u16
)filter
[4] | ((u16
)filter
[5] << 8));
2441 gma_write16(hw
, port
, GM_MC_ADDR_H4
,
2442 (u16
)filter
[6] | ((u16
)filter
[7] << 8));
2444 gma_write16(hw
, port
, GM_RX_CTRL
, reg
);
2447 static inline int bad_phy_status(const struct skge_hw
*hw
, u32 status
)
2449 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2450 return (status
& (XMR_FS_ERR
| XMR_FS_2L_VLAN
)) != 0;
2452 return (status
& GMR_FS_ANY_ERR
) ||
2453 (status
& GMR_FS_RX_OK
) == 0;
2456 static void skge_rx_error(struct skge_port
*skge
, int slot
,
2457 u32 control
, u32 status
)
2459 if (netif_msg_rx_err(skge
))
2460 printk(KERN_DEBUG PFX
"%s: rx err, slot %d control 0x%x status 0x%x\n",
2461 skge
->netdev
->name
, slot
, control
, status
);
2463 if ((control
& (BMU_EOF
|BMU_STF
)) != (BMU_STF
|BMU_EOF
))
2464 skge
->net_stats
.rx_length_errors
++;
2465 else if (skge
->hw
->chip_id
== CHIP_ID_GENESIS
) {
2466 if (status
& (XMR_FS_RUNT
|XMR_FS_LNG_ERR
))
2467 skge
->net_stats
.rx_length_errors
++;
2468 if (status
& XMR_FS_FRA_ERR
)
2469 skge
->net_stats
.rx_frame_errors
++;
2470 if (status
& XMR_FS_FCS_ERR
)
2471 skge
->net_stats
.rx_crc_errors
++;
2473 if (status
& (GMR_FS_LONG_ERR
|GMR_FS_UN_SIZE
))
2474 skge
->net_stats
.rx_length_errors
++;
2475 if (status
& GMR_FS_FRAGMENT
)
2476 skge
->net_stats
.rx_frame_errors
++;
2477 if (status
& GMR_FS_CRC_ERR
)
2478 skge
->net_stats
.rx_crc_errors
++;
2482 /* Get receive buffer from descriptor.
2483 * Handles copy of small buffers and reallocation failures
2485 static inline struct sk_buff
*skge_rx_get(struct skge_port
*skge
,
2486 struct skge_element
*e
,
2489 struct sk_buff
*nskb
, *skb
;
2491 if (len
< RX_COPY_THRESHOLD
) {
2492 nskb
= skge_rx_alloc(skge
->netdev
, len
+ NET_IP_ALIGN
);
2493 if (unlikely(!nskb
))
2496 pci_dma_sync_single_for_cpu(skge
->hw
->pdev
,
2497 pci_unmap_addr(e
, mapaddr
),
2498 len
, PCI_DMA_FROMDEVICE
);
2499 memcpy(nskb
->data
, e
->skb
->data
, len
);
2500 pci_dma_sync_single_for_device(skge
->hw
->pdev
,
2501 pci_unmap_addr(e
, mapaddr
),
2502 len
, PCI_DMA_FROMDEVICE
);
2504 if (skge
->rx_csum
) {
2505 struct skge_rx_desc
*rd
= e
->desc
;
2506 nskb
->csum
= le16_to_cpu(rd
->csum2
);
2507 nskb
->ip_summed
= CHECKSUM_HW
;
2509 skge_rx_reuse(e
, skge
->rx_buf_size
);
2512 nskb
= skge_rx_alloc(skge
->netdev
, skge
->rx_buf_size
);
2513 if (unlikely(!nskb
))
2516 pci_unmap_single(skge
->hw
->pdev
,
2517 pci_unmap_addr(e
, mapaddr
),
2518 pci_unmap_len(e
, maplen
),
2519 PCI_DMA_FROMDEVICE
);
2521 if (skge
->rx_csum
) {
2522 struct skge_rx_desc
*rd
= e
->desc
;
2523 skb
->csum
= le16_to_cpu(rd
->csum2
);
2524 skb
->ip_summed
= CHECKSUM_HW
;
2527 skge_rx_setup(skge
, e
, nskb
, skge
->rx_buf_size
);
2533 static int skge_poll(struct net_device
*dev
, int *budget
)
2535 struct skge_port
*skge
= netdev_priv(dev
);
2536 struct skge_hw
*hw
= skge
->hw
;
2537 struct skge_ring
*ring
= &skge
->rx_ring
;
2538 struct skge_element
*e
;
2539 unsigned int to_do
= min(dev
->quota
, *budget
);
2540 unsigned int work_done
= 0;
2542 pr_debug("skge_poll\n");
2544 for (e
= ring
->to_clean
; work_done
< to_do
; e
= e
->next
) {
2545 struct skge_rx_desc
*rd
= e
->desc
;
2546 struct sk_buff
*skb
;
2547 u32 control
, len
, status
;
2550 control
= rd
->control
;
2551 if (control
& BMU_OWN
)
2554 len
= control
& BMU_BBC
;
2555 status
= rd
->status
;
2557 if (unlikely((control
& (BMU_EOF
|BMU_STF
)) != (BMU_STF
|BMU_EOF
)
2558 || bad_phy_status(hw
, status
))) {
2559 skge_rx_error(skge
, e
- ring
->start
, control
, status
);
2560 skge_rx_reuse(e
, skge
->rx_buf_size
);
2564 if (netif_msg_rx_status(skge
))
2565 printk(KERN_DEBUG PFX
"%s: rx slot %td status 0x%x len %d\n",
2566 dev
->name
, e
- ring
->start
, rd
->status
, len
);
2568 skb
= skge_rx_get(skge
, e
, len
);
2571 skb
->protocol
= eth_type_trans(skb
, dev
);
2573 dev
->last_rx
= jiffies
;
2574 netif_receive_skb(skb
);
2578 skge_rx_reuse(e
, skge
->rx_buf_size
);
2582 /* restart receiver */
2584 skge_write8(hw
, Q_ADDR(rxqaddr
[skge
->port
], Q_CSR
),
2585 CSR_START
| CSR_IRQ_CL_F
);
2587 *budget
-= work_done
;
2588 dev
->quota
-= work_done
;
2590 if (work_done
>= to_do
)
2591 return 1; /* not done */
2593 local_irq_disable();
2594 __netif_rx_complete(dev
);
2595 hw
->intr_mask
|= portirqmask
[skge
->port
];
2596 skge_write32(hw
, B0_IMSK
, hw
->intr_mask
);
2601 static inline void skge_tx_intr(struct net_device
*dev
)
2603 struct skge_port
*skge
= netdev_priv(dev
);
2604 struct skge_hw
*hw
= skge
->hw
;
2605 struct skge_ring
*ring
= &skge
->tx_ring
;
2606 struct skge_element
*e
;
2608 spin_lock(&skge
->tx_lock
);
2609 for (e
= ring
->to_clean
; e
!= ring
->to_use
; e
= e
->next
) {
2610 struct skge_tx_desc
*td
= e
->desc
;
2614 control
= td
->control
;
2615 if (control
& BMU_OWN
)
2618 if (unlikely(netif_msg_tx_done(skge
)))
2619 printk(KERN_DEBUG PFX
"%s: tx done slot %td status 0x%x\n",
2620 dev
->name
, e
- ring
->start
, td
->status
);
2622 skge_tx_free(hw
, e
);
2627 skge_write8(hw
, Q_ADDR(txqaddr
[skge
->port
], Q_CSR
), CSR_IRQ_CL_F
);
2629 if (skge
->tx_avail
> MAX_SKB_FRAGS
+ 1)
2630 netif_wake_queue(dev
);
2632 spin_unlock(&skge
->tx_lock
);
2635 /* Parity errors seem to happen when Genesis is connected to a switch
2636 * with no other ports present. Heartbeat error??
2638 static void skge_mac_parity(struct skge_hw
*hw
, int port
)
2640 struct net_device
*dev
= hw
->dev
[port
];
2643 struct skge_port
*skge
= netdev_priv(dev
);
2644 ++skge
->net_stats
.tx_heartbeat_errors
;
2647 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2648 skge_write16(hw
, SK_REG(port
, TX_MFF_CTRL1
),
2651 /* HW-Bug #8: cleared by GMF_CLI_TX_FC instead of GMF_CLI_TX_PE */
2652 skge_write8(hw
, SK_REG(port
, TX_GMF_CTRL_T
),
2653 (hw
->chip_id
== CHIP_ID_YUKON
&& hw
->chip_rev
== 0)
2654 ? GMF_CLI_TX_FC
: GMF_CLI_TX_PE
);
2657 static void skge_pci_clear(struct skge_hw
*hw
)
2661 pci_read_config_word(hw
->pdev
, PCI_STATUS
, &status
);
2662 skge_write8(hw
, B2_TST_CTRL1
, TST_CFG_WRITE_ON
);
2663 pci_write_config_word(hw
->pdev
, PCI_STATUS
,
2664 status
| PCI_STATUS_ERROR_BITS
);
2665 skge_write8(hw
, B2_TST_CTRL1
, TST_CFG_WRITE_OFF
);
2668 static void skge_mac_intr(struct skge_hw
*hw
, int port
)
2670 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2671 genesis_mac_intr(hw
, port
);
2673 yukon_mac_intr(hw
, port
);
2676 /* Handle device specific framing and timeout interrupts */
2677 static void skge_error_irq(struct skge_hw
*hw
)
2679 u32 hwstatus
= skge_read32(hw
, B0_HWE_ISRC
);
2681 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
2682 /* clear xmac errors */
2683 if (hwstatus
& (IS_NO_STAT_M1
|IS_NO_TIST_M1
))
2684 skge_write16(hw
, SK_REG(0, RX_MFF_CTRL1
), MFF_CLR_INSTAT
);
2685 if (hwstatus
& (IS_NO_STAT_M2
|IS_NO_TIST_M2
))
2686 skge_write16(hw
, SK_REG(0, RX_MFF_CTRL2
), MFF_CLR_INSTAT
);
2688 /* Timestamp (unused) overflow */
2689 if (hwstatus
& IS_IRQ_TIST_OV
)
2690 skge_write8(hw
, GMAC_TI_ST_CTRL
, GMT_ST_CLR_IRQ
);
2692 if (hwstatus
& IS_IRQ_SENSOR
) {
2693 /* no sensors on 32-bit Yukon */
2694 if (!(skge_read16(hw
, B0_CTST
) & CS_BUS_SLOT_SZ
)) {
2695 printk(KERN_ERR PFX
"ignoring bogus sensor interrups\n");
2696 skge_write32(hw
, B0_HWE_IMSK
,
2697 IS_ERR_MSK
& ~IS_IRQ_SENSOR
);
2699 printk(KERN_WARNING PFX
"sensor interrupt\n");
2705 if (hwstatus
& IS_RAM_RD_PAR
) {
2706 printk(KERN_ERR PFX
"Ram read data parity error\n");
2707 skge_write16(hw
, B3_RI_CTRL
, RI_CLR_RD_PERR
);
2710 if (hwstatus
& IS_RAM_WR_PAR
) {
2711 printk(KERN_ERR PFX
"Ram write data parity error\n");
2712 skge_write16(hw
, B3_RI_CTRL
, RI_CLR_WR_PERR
);
2715 if (hwstatus
& IS_M1_PAR_ERR
)
2716 skge_mac_parity(hw
, 0);
2718 if (hwstatus
& IS_M2_PAR_ERR
)
2719 skge_mac_parity(hw
, 1);
2721 if (hwstatus
& IS_R1_PAR_ERR
)
2722 skge_write32(hw
, B0_R1_CSR
, CSR_IRQ_CL_P
);
2724 if (hwstatus
& IS_R2_PAR_ERR
)
2725 skge_write32(hw
, B0_R2_CSR
, CSR_IRQ_CL_P
);
2727 if (hwstatus
& (IS_IRQ_MST_ERR
|IS_IRQ_STAT
)) {
2728 printk(KERN_ERR PFX
"hardware error detected (status 0x%x)\n",
2733 hwstatus
= skge_read32(hw
, B0_HWE_ISRC
);
2734 if (hwstatus
& IS_IRQ_STAT
) {
2735 printk(KERN_WARNING PFX
"IRQ status %x: still set ignoring hardware errors\n",
2737 hw
->intr_mask
&= ~IS_HW_ERR
;
2743 * Interrrupt from PHY are handled in tasklet (soft irq)
2744 * because accessing phy registers requires spin wait which might
2745 * cause excess interrupt latency.
2747 static void skge_extirq(unsigned long data
)
2749 struct skge_hw
*hw
= (struct skge_hw
*) data
;
2752 spin_lock(&hw
->phy_lock
);
2753 for (port
= 0; port
< 2; port
++) {
2754 struct net_device
*dev
= hw
->dev
[port
];
2756 if (dev
&& netif_running(dev
)) {
2757 struct skge_port
*skge
= netdev_priv(dev
);
2759 if (hw
->chip_id
!= CHIP_ID_GENESIS
)
2760 yukon_phy_intr(skge
);
2762 bcom_phy_intr(skge
);
2765 spin_unlock(&hw
->phy_lock
);
2767 local_irq_disable();
2768 hw
->intr_mask
|= IS_EXT_REG
;
2769 skge_write32(hw
, B0_IMSK
, hw
->intr_mask
);
2773 static irqreturn_t
skge_intr(int irq
, void *dev_id
, struct pt_regs
*regs
)
2775 struct skge_hw
*hw
= dev_id
;
2776 u32 status
= skge_read32(hw
, B0_SP_ISRC
);
2778 if (status
== 0 || status
== ~0) /* hotplug or shared irq */
2781 status
&= hw
->intr_mask
;
2782 if (status
& IS_R1_F
) {
2783 hw
->intr_mask
&= ~IS_R1_F
;
2784 netif_rx_schedule(hw
->dev
[0]);
2787 if (status
& IS_R2_F
) {
2788 hw
->intr_mask
&= ~IS_R2_F
;
2789 netif_rx_schedule(hw
->dev
[1]);
2792 if (status
& IS_XA1_F
)
2793 skge_tx_intr(hw
->dev
[0]);
2795 if (status
& IS_XA2_F
)
2796 skge_tx_intr(hw
->dev
[1]);
2798 if (status
& IS_PA_TO_RX1
) {
2799 struct skge_port
*skge
= netdev_priv(hw
->dev
[0]);
2800 ++skge
->net_stats
.rx_over_errors
;
2801 skge_write16(hw
, B3_PA_CTRL
, PA_CLR_TO_RX1
);
2804 if (status
& IS_PA_TO_RX2
) {
2805 struct skge_port
*skge
= netdev_priv(hw
->dev
[1]);
2806 ++skge
->net_stats
.rx_over_errors
;
2807 skge_write16(hw
, B3_PA_CTRL
, PA_CLR_TO_RX2
);
2810 if (status
& IS_PA_TO_TX1
)
2811 skge_write16(hw
, B3_PA_CTRL
, PA_CLR_TO_TX1
);
2813 if (status
& IS_PA_TO_TX2
)
2814 skge_write16(hw
, B3_PA_CTRL
, PA_CLR_TO_TX2
);
2816 if (status
& IS_MAC1
)
2817 skge_mac_intr(hw
, 0);
2819 if (status
& IS_MAC2
)
2820 skge_mac_intr(hw
, 1);
2822 if (status
& IS_HW_ERR
)
2825 if (status
& IS_EXT_REG
) {
2826 hw
->intr_mask
&= ~IS_EXT_REG
;
2827 tasklet_schedule(&hw
->ext_tasklet
);
2830 skge_write32(hw
, B0_IMSK
, hw
->intr_mask
);
2835 #ifdef CONFIG_NET_POLL_CONTROLLER
2836 static void skge_netpoll(struct net_device
*dev
)
2838 struct skge_port
*skge
= netdev_priv(dev
);
2840 disable_irq(dev
->irq
);
2841 skge_intr(dev
->irq
, skge
->hw
, NULL
);
2842 enable_irq(dev
->irq
);
2846 static int skge_set_mac_address(struct net_device
*dev
, void *p
)
2848 struct skge_port
*skge
= netdev_priv(dev
);
2849 struct sockaddr
*addr
= p
;
2852 if (!is_valid_ether_addr(addr
->sa_data
))
2853 return -EADDRNOTAVAIL
;
2856 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
2857 memcpy_toio(skge
->hw
->regs
+ B2_MAC_1
+ skge
->port
*8,
2858 dev
->dev_addr
, ETH_ALEN
);
2859 memcpy_toio(skge
->hw
->regs
+ B2_MAC_2
+ skge
->port
*8,
2860 dev
->dev_addr
, ETH_ALEN
);
2861 if (dev
->flags
& IFF_UP
)
2866 static const struct {
2870 { CHIP_ID_GENESIS
, "Genesis" },
2871 { CHIP_ID_YUKON
, "Yukon" },
2872 { CHIP_ID_YUKON_LITE
, "Yukon-Lite"},
2873 { CHIP_ID_YUKON_LP
, "Yukon-LP"},
2876 static const char *skge_board_name(const struct skge_hw
*hw
)
2879 static char buf
[16];
2881 for (i
= 0; i
< ARRAY_SIZE(skge_chips
); i
++)
2882 if (skge_chips
[i
].id
== hw
->chip_id
)
2883 return skge_chips
[i
].name
;
2885 snprintf(buf
, sizeof buf
, "chipid 0x%x", hw
->chip_id
);
2891 * Setup the board data structure, but don't bring up
2894 static int skge_reset(struct skge_hw
*hw
)
2900 ctst
= skge_read16(hw
, B0_CTST
);
2903 skge_write8(hw
, B0_CTST
, CS_RST_SET
);
2904 skge_write8(hw
, B0_CTST
, CS_RST_CLR
);
2906 /* clear PCI errors, if any */
2909 skge_write8(hw
, B0_CTST
, CS_MRST_CLR
);
2911 /* restore CLK_RUN bits (for Yukon-Lite) */
2912 skge_write16(hw
, B0_CTST
,
2913 ctst
& (CS_CLK_RUN_HOT
|CS_CLK_RUN_RST
|CS_CLK_RUN_ENA
));
2915 hw
->chip_id
= skge_read8(hw
, B2_CHIP_ID
);
2916 hw
->phy_type
= skge_read8(hw
, B2_E_1
) & 0xf;
2917 hw
->pmd_type
= skge_read8(hw
, B2_PMD_TYP
);
2919 switch (hw
->chip_id
) {
2920 case CHIP_ID_GENESIS
:
2921 switch (hw
->phy_type
) {
2923 hw
->phy_addr
= PHY_ADDR_BCOM
;
2926 printk(KERN_ERR PFX
"%s: unsupported phy type 0x%x\n",
2927 pci_name(hw
->pdev
), hw
->phy_type
);
2933 case CHIP_ID_YUKON_LITE
:
2934 case CHIP_ID_YUKON_LP
:
2935 if (hw
->phy_type
< SK_PHY_MARV_COPPER
&& hw
->pmd_type
!= 'S')
2936 hw
->phy_type
= SK_PHY_MARV_COPPER
;
2938 hw
->phy_addr
= PHY_ADDR_MARV
;
2940 hw
->phy_type
= SK_PHY_MARV_FIBER
;
2945 printk(KERN_ERR PFX
"%s: unsupported chip type 0x%x\n",
2946 pci_name(hw
->pdev
), hw
->chip_id
);
2950 mac_cfg
= skge_read8(hw
, B2_MAC_CFG
);
2951 hw
->ports
= (mac_cfg
& CFG_SNG_MAC
) ? 1 : 2;
2952 hw
->chip_rev
= (mac_cfg
& CFG_CHIP_R_MSK
) >> 4;
2954 /* read the adapters RAM size */
2955 t8
= skge_read8(hw
, B2_E_0
);
2956 if (hw
->chip_id
== CHIP_ID_GENESIS
) {
2958 /* special case: 4 x 64k x 36, offset = 0x80000 */
2959 hw
->ram_size
= 0x100000;
2960 hw
->ram_offset
= 0x80000;
2962 hw
->ram_size
= t8
* 512;
2965 hw
->ram_size
= 0x20000;
2967 hw
->ram_size
= t8
* 4096;
2969 if (hw
->chip_id
== CHIP_ID_GENESIS
)
2972 /* switch power to VCC (WA for VAUX problem) */
2973 skge_write8(hw
, B0_POWER_CTRL
,
2974 PC_VAUX_ENA
| PC_VCC_ENA
| PC_VAUX_OFF
| PC_VCC_ON
);
2975 for (i
= 0; i
< hw
->ports
; i
++) {
2976 skge_write16(hw
, SK_REG(i
, GMAC_LINK_CTRL
), GMLC_RST_SET
);
2977 skge_write16(hw
, SK_REG(i
, GMAC_LINK_CTRL
), GMLC_RST_CLR
);
2981 /* turn off hardware timer (unused) */
2982 skge_write8(hw
, B2_TI_CTRL
, TIM_STOP
);
2983 skge_write8(hw
, B2_TI_CTRL
, TIM_CLR_IRQ
);
2984 skge_write8(hw
, B0_LED
, LED_STAT_ON
);
2986 /* enable the Tx Arbiters */
2987 for (i
= 0; i
< hw
->ports
; i
++)
2988 skge_write8(hw
, SK_REG(i
, TXA_CTRL
), TXA_ENA_ARB
);
2990 /* Initialize ram interface */
2991 skge_write16(hw
, B3_RI_CTRL
, RI_RST_CLR
);
2993 skge_write8(hw
, B3_RI_WTO_R1
, SK_RI_TO_53
);
2994 skge_write8(hw
, B3_RI_WTO_XA1
, SK_RI_TO_53
);
2995 skge_write8(hw
, B3_RI_WTO_XS1
, SK_RI_TO_53
);
2996 skge_write8(hw
, B3_RI_RTO_R1
, SK_RI_TO_53
);
2997 skge_write8(hw
, B3_RI_RTO_XA1
, SK_RI_TO_53
);
2998 skge_write8(hw
, B3_RI_RTO_XS1
, SK_RI_TO_53
);
2999 skge_write8(hw
, B3_RI_WTO_R2
, SK_RI_TO_53
);
3000 skge_write8(hw
, B3_RI_WTO_XA2
, SK_RI_TO_53
);
3001 skge_write8(hw
, B3_RI_WTO_XS2
, SK_RI_TO_53
);
3002 skge_write8(hw
, B3_RI_RTO_R2
, SK_RI_TO_53
);
3003 skge_write8(hw
, B3_RI_RTO_XA2
, SK_RI_TO_53
);
3004 skge_write8(hw
, B3_RI_RTO_XS2
, SK_RI_TO_53
);
3006 skge_write32(hw
, B0_HWE_IMSK
, IS_ERR_MSK
);
3008 /* Set interrupt moderation for Transmit only
3009 * Receive interrupts avoided by NAPI
3011 skge_write32(hw
, B2_IRQM_MSK
, IS_XA1_F
|IS_XA2_F
);
3012 skge_write32(hw
, B2_IRQM_INI
, skge_usecs2clk(hw
, 100));
3013 skge_write32(hw
, B2_IRQM_CTRL
, TIM_START
);
3015 hw
->intr_mask
= IS_HW_ERR
| IS_EXT_REG
;
3016 skge_write32(hw
, B0_IMSK
, hw
->intr_mask
);
3018 if (hw
->chip_id
!= CHIP_ID_GENESIS
)
3019 skge_write8(hw
, GMAC_IRQ_MSK
, 0);
3021 spin_lock_bh(&hw
->phy_lock
);
3022 for (i
= 0; i
< hw
->ports
; i
++) {
3023 if (hw
->chip_id
== CHIP_ID_GENESIS
)
3024 genesis_reset(hw
, i
);
3028 spin_unlock_bh(&hw
->phy_lock
);
3033 /* Initialize network device */
3034 static struct net_device
*skge_devinit(struct skge_hw
*hw
, int port
,
3037 struct skge_port
*skge
;
3038 struct net_device
*dev
= alloc_etherdev(sizeof(*skge
));
3041 printk(KERN_ERR
"skge etherdev alloc failed");
3045 SET_MODULE_OWNER(dev
);
3046 SET_NETDEV_DEV(dev
, &hw
->pdev
->dev
);
3047 dev
->open
= skge_up
;
3048 dev
->stop
= skge_down
;
3049 dev
->hard_start_xmit
= skge_xmit_frame
;
3050 dev
->get_stats
= skge_get_stats
;
3051 if (hw
->chip_id
== CHIP_ID_GENESIS
)
3052 dev
->set_multicast_list
= genesis_set_multicast
;
3054 dev
->set_multicast_list
= yukon_set_multicast
;
3056 dev
->set_mac_address
= skge_set_mac_address
;
3057 dev
->change_mtu
= skge_change_mtu
;
3058 SET_ETHTOOL_OPS(dev
, &skge_ethtool_ops
);
3059 dev
->tx_timeout
= skge_tx_timeout
;
3060 dev
->watchdog_timeo
= TX_WATCHDOG
;
3061 dev
->poll
= skge_poll
;
3062 dev
->weight
= NAPI_WEIGHT
;
3063 #ifdef CONFIG_NET_POLL_CONTROLLER
3064 dev
->poll_controller
= skge_netpoll
;
3066 dev
->irq
= hw
->pdev
->irq
;
3067 dev
->features
= NETIF_F_LLTX
;
3069 dev
->features
|= NETIF_F_HIGHDMA
;
3071 skge
= netdev_priv(dev
);
3074 skge
->msg_enable
= netif_msg_init(debug
, default_msg
);
3075 skge
->tx_ring
.count
= DEFAULT_TX_RING_SIZE
;
3076 skge
->rx_ring
.count
= DEFAULT_RX_RING_SIZE
;
3078 /* Auto speed and flow control */
3079 skge
->autoneg
= AUTONEG_ENABLE
;
3080 skge
->flow_control
= FLOW_MODE_SYMMETRIC
;
3083 skge
->advertising
= skge_supported_modes(hw
);
3085 hw
->dev
[port
] = dev
;
3089 spin_lock_init(&skge
->tx_lock
);
3091 init_timer(&skge
->led_blink
);
3092 skge
->led_blink
.function
= skge_blink_timer
;
3093 skge
->led_blink
.data
= (unsigned long) skge
;
3095 if (hw
->chip_id
!= CHIP_ID_GENESIS
) {
3096 dev
->features
|= NETIF_F_IP_CSUM
| NETIF_F_SG
;
3100 /* read the mac address */
3101 memcpy_fromio(dev
->dev_addr
, hw
->regs
+ B2_MAC_1
+ port
*8, ETH_ALEN
);
3103 /* device is off until link detection */
3104 netif_carrier_off(dev
);
3105 netif_stop_queue(dev
);
3110 static void __devinit
skge_show_addr(struct net_device
*dev
)
3112 const struct skge_port
*skge
= netdev_priv(dev
);
3114 if (netif_msg_probe(skge
))
3115 printk(KERN_INFO PFX
"%s: addr %02x:%02x:%02x:%02x:%02x:%02x\n",
3117 dev
->dev_addr
[0], dev
->dev_addr
[1], dev
->dev_addr
[2],
3118 dev
->dev_addr
[3], dev
->dev_addr
[4], dev
->dev_addr
[5]);
3121 static int __devinit
skge_probe(struct pci_dev
*pdev
,
3122 const struct pci_device_id
*ent
)
3124 struct net_device
*dev
, *dev1
;
3126 int err
, using_dac
= 0;
3128 if ((err
= pci_enable_device(pdev
))) {
3129 printk(KERN_ERR PFX
"%s cannot enable PCI device\n",
3134 if ((err
= pci_request_regions(pdev
, DRV_NAME
))) {
3135 printk(KERN_ERR PFX
"%s cannot obtain PCI resources\n",
3137 goto err_out_disable_pdev
;
3140 pci_set_master(pdev
);
3142 if (!(err
= pci_set_dma_mask(pdev
, DMA_64BIT_MASK
)))
3144 else if (!(err
= pci_set_dma_mask(pdev
, DMA_32BIT_MASK
))) {
3145 printk(KERN_ERR PFX
"%s no usable DMA configuration\n",
3147 goto err_out_free_regions
;
3151 /* byte swap decriptors in hardware */
3155 pci_read_config_dword(pdev
, PCI_DEV_REG2
, ®
);
3156 reg
|= PCI_REV_DESC
;
3157 pci_write_config_dword(pdev
, PCI_DEV_REG2
, reg
);
3162 hw
= kmalloc(sizeof(*hw
), GFP_KERNEL
);
3164 printk(KERN_ERR PFX
"%s: cannot allocate hardware struct\n",
3166 goto err_out_free_regions
;
3169 memset(hw
, 0, sizeof(*hw
));
3171 spin_lock_init(&hw
->phy_lock
);
3172 tasklet_init(&hw
->ext_tasklet
, skge_extirq
, (unsigned long) hw
);
3174 hw
->regs
= ioremap_nocache(pci_resource_start(pdev
, 0), 0x4000);
3176 printk(KERN_ERR PFX
"%s: cannot map device registers\n",
3178 goto err_out_free_hw
;
3181 if ((err
= request_irq(pdev
->irq
, skge_intr
, SA_SHIRQ
, DRV_NAME
, hw
))) {
3182 printk(KERN_ERR PFX
"%s: cannot assign irq %d\n",
3183 pci_name(pdev
), pdev
->irq
);
3184 goto err_out_iounmap
;
3186 pci_set_drvdata(pdev
, hw
);
3188 err
= skge_reset(hw
);
3190 goto err_out_free_irq
;
3192 printk(KERN_INFO PFX
"addr 0x%lx irq %d chip %s rev %d\n",
3193 pci_resource_start(pdev
, 0), pdev
->irq
,
3194 skge_board_name(hw
), hw
->chip_rev
);
3196 if ((dev
= skge_devinit(hw
, 0, using_dac
)) == NULL
)
3197 goto err_out_led_off
;
3199 if ((err
= register_netdev(dev
))) {
3200 printk(KERN_ERR PFX
"%s: cannot register net device\n",
3202 goto err_out_free_netdev
;
3205 skge_show_addr(dev
);
3207 if (hw
->ports
> 1 && (dev1
= skge_devinit(hw
, 1, using_dac
))) {
3208 if (register_netdev(dev1
) == 0)
3209 skge_show_addr(dev1
);
3211 /* Failure to register second port need not be fatal */
3212 printk(KERN_WARNING PFX
"register of second port failed\n");
3220 err_out_free_netdev
:
3223 skge_write16(hw
, B0_LED
, LED_STAT_OFF
);
3225 free_irq(pdev
->irq
, hw
);
3230 err_out_free_regions
:
3231 pci_release_regions(pdev
);
3232 err_out_disable_pdev
:
3233 pci_disable_device(pdev
);
3234 pci_set_drvdata(pdev
, NULL
);
3239 static void __devexit
skge_remove(struct pci_dev
*pdev
)
3241 struct skge_hw
*hw
= pci_get_drvdata(pdev
);
3242 struct net_device
*dev0
, *dev1
;
3247 if ((dev1
= hw
->dev
[1]))
3248 unregister_netdev(dev1
);
3250 unregister_netdev(dev0
);
3252 tasklet_kill(&hw
->ext_tasklet
);
3254 free_irq(pdev
->irq
, hw
);
3255 pci_release_regions(pdev
);
3256 pci_disable_device(pdev
);
3260 skge_write16(hw
, B0_LED
, LED_STAT_OFF
);
3263 pci_set_drvdata(pdev
, NULL
);
3267 static int skge_suspend(struct pci_dev
*pdev
, pm_message_t state
)
3269 struct skge_hw
*hw
= pci_get_drvdata(pdev
);
3272 for (i
= 0; i
< 2; i
++) {
3273 struct net_device
*dev
= hw
->dev
[i
];
3276 struct skge_port
*skge
= netdev_priv(dev
);
3277 if (netif_running(dev
)) {
3278 netif_carrier_off(dev
);
3281 netif_device_detach(dev
);
3286 pci_save_state(pdev
);
3287 pci_enable_wake(pdev
, pci_choose_state(pdev
, state
), wol
);
3288 pci_disable_device(pdev
);
3289 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
3294 static int skge_resume(struct pci_dev
*pdev
)
3296 struct skge_hw
*hw
= pci_get_drvdata(pdev
);
3299 pci_set_power_state(pdev
, PCI_D0
);
3300 pci_restore_state(pdev
);
3301 pci_enable_wake(pdev
, PCI_D0
, 0);
3305 for (i
= 0; i
< 2; i
++) {
3306 struct net_device
*dev
= hw
->dev
[i
];
3308 netif_device_attach(dev
);
3309 if (netif_running(dev
))
3317 static struct pci_driver skge_driver
= {
3319 .id_table
= skge_id_table
,
3320 .probe
= skge_probe
,
3321 .remove
= __devexit_p(skge_remove
),
3323 .suspend
= skge_suspend
,
3324 .resume
= skge_resume
,
3328 static int __init
skge_init_module(void)
3330 return pci_module_init(&skge_driver
);
3333 static void __exit
skge_cleanup_module(void)
3335 pci_unregister_driver(&skge_driver
);
3338 module_init(skge_init_module
);
3339 module_exit(skge_cleanup_module
);