diff options
author | Stephen Hemminger <shemminger@osdl.org> | 2005-08-16 19:36:49 -0400 |
---|---|---|
committer | Jeff Garzik <jgarzik@pobox.com> | 2005-08-17 00:53:12 -0400 |
commit | cd28ab6a4e50a7601d22752aa7ce0c8197b10bdf (patch) | |
tree | 7030ba1742db21caebe491c9052f312e30c33628 /drivers | |
parent | 2ba84684e8cf6f980e4e95a2300f53a505eb794e (diff) |
[PATCH] sky2: new experimental Marvell Yukon2 driver
New driver for the Marvell Yukon2 Gigabit Ethernet chipset.
This driver is based on the skge driver, but using the logic
from the SysKonnect version of the sk98lin driver.
It should support all the Yukon2 chipsets that are available
in many current Intel and AMD motherboards.
The driver does support ethtool, tx and rx checksum, and
tcp segmentation offload. But it has only been tested for
a short while and is known to stop receiving under heavy load.
Signed-off-by: Stephen Hemminger <shemminger@osdl.org>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/net/Kconfig | 20 | ||||
-rw-r--r-- | drivers/net/Makefile | 1 | ||||
-rw-r--r-- | drivers/net/sky2.c | 2686 | ||||
-rw-r--r-- | drivers/net/sky2.h | 1935 |
4 files changed, 4641 insertions, 1 deletions
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig index 8a835eb58808..4d7489ae5e24 100644 --- a/drivers/net/Kconfig +++ b/drivers/net/Kconfig | |||
@@ -1932,7 +1932,25 @@ config SKGE | |||
1932 | 1932 | ||
1933 | It does not support the link failover and network management | 1933 | It does not support the link failover and network management |
1934 | features that "portable" vendor supplied sk98lin driver does. | 1934 | features that "portable" vendor supplied sk98lin driver does. |
1935 | 1935 | ||
1936 | |||
1937 | config SKY2 | ||
1938 | tristate "SysKonnect Yukon2 support (EXPERIMENTAL)" | ||
1939 | depends on PCI && EXPERIMENTAL | ||
1940 | select CRC32 | ||
1941 | ---help--- | ||
1942 | This driver support the Marvell Yukon 2 Gigabit Ethernet adapter. | ||
1943 | |||
1944 | To compile this driver as a module, choose M here: the module | ||
1945 | will be called sky2. This is recommended. | ||
1946 | |||
1947 | config SKY2_EC_A1 | ||
1948 | bool "Support old Yukon-EC A1 chipset" | ||
1949 | depends on SKY2 | ||
1950 | ---help--- | ||
1951 | Include support for early revisions of the Yukon EC chipset | ||
1952 | that required extra workarounds. If in doubt, say N. | ||
1953 | |||
1936 | config SK98LIN | 1954 | config SK98LIN |
1937 | tristate "Marvell Yukon Chipset / SysKonnect SK-98xx Support" | 1955 | tristate "Marvell Yukon Chipset / SysKonnect SK-98xx Support" |
1938 | depends on PCI | 1956 | depends on PCI |
diff --git a/drivers/net/Makefile b/drivers/net/Makefile index 63c6d1e6d4d9..7e5c0d46d505 100644 --- a/drivers/net/Makefile +++ b/drivers/net/Makefile | |||
@@ -54,6 +54,7 @@ obj-$(CONFIG_TIGON3) += tg3.o | |||
54 | obj-$(CONFIG_BNX2) += bnx2.o | 54 | obj-$(CONFIG_BNX2) += bnx2.o |
55 | obj-$(CONFIG_TC35815) += tc35815.o | 55 | obj-$(CONFIG_TC35815) += tc35815.o |
56 | obj-$(CONFIG_SKGE) += skge.o | 56 | obj-$(CONFIG_SKGE) += skge.o |
57 | obj-$(CONFIG_SKY2) += sky2.o | ||
57 | obj-$(CONFIG_SK98LIN) += sk98lin/ | 58 | obj-$(CONFIG_SK98LIN) += sk98lin/ |
58 | obj-$(CONFIG_SKFP) += skfp/ | 59 | obj-$(CONFIG_SKFP) += skfp/ |
59 | obj-$(CONFIG_VIA_RHINE) += via-rhine.o | 60 | obj-$(CONFIG_VIA_RHINE) += via-rhine.o |
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c new file mode 100644 index 000000000000..cfb2b41bc6b2 --- /dev/null +++ b/drivers/net/sky2.c | |||
@@ -0,0 +1,2686 @@ | |||
1 | /* | ||
2 | * New driver for Marvell Yukon 2 chipset. | ||
3 | * Based on earlier sk98lin, and skge driver. | ||
4 | * | ||
5 | * This driver intentionally does not support all the features | ||
6 | * of the original driver such as link fail-over and link management because | ||
7 | * those should be done at higher levels. | ||
8 | * | ||
9 | * Copyright (C) 2005 Stephen Hemminger <shemminger@osdl.org> | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation; either version 2 of the License, or | ||
14 | * (at your option) any later version. | ||
15 | * | ||
16 | * This program is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with this program; if not, write to the Free Software | ||
23 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
24 | */ | ||
25 | |||
26 | /* | ||
27 | * TODO | ||
28 | * - coalescing setting? | ||
29 | * - variable ring size? | ||
30 | * | ||
31 | * TOTEST | ||
32 | * - speed setting | ||
33 | * - power management | ||
34 | */ | ||
35 | |||
36 | #include <linux/config.h> | ||
37 | #include <linux/kernel.h> | ||
38 | #include <linux/version.h> | ||
39 | #include <linux/module.h> | ||
40 | #include <linux/netdevice.h> | ||
41 | #include <linux/etherdevice.h> | ||
42 | #include <linux/ethtool.h> | ||
43 | #include <linux/pci.h> | ||
44 | #include <linux/ip.h> | ||
45 | #include <linux/tcp.h> | ||
46 | #include <linux/in.h> | ||
47 | #include <linux/delay.h> | ||
48 | #include <linux/crc32.h> | ||
49 | |||
50 | #include <asm/irq.h> | ||
51 | |||
52 | #include "sky2.h" | ||
53 | |||
54 | #define DRV_NAME "sky2" | ||
55 | #define DRV_VERSION "0.2" | ||
56 | #define PFX DRV_NAME " " | ||
57 | |||
58 | /* | ||
59 | * The Yukon II chipset takes 64 bit command blocks (called list elements) | ||
60 | * that are organized into three (receive, transmit, status) different rings | ||
61 | * similar to Tigon3. A transmit can require several elements; | ||
62 | * a receive requires one (or two if using 64 bit dma). | ||
63 | */ | ||
64 | |||
65 | #ifdef CONFIG_SKY2_EC_A1 | ||
66 | #define is_ec_a1(hw) \ | ||
67 | ((hw)->chip_id == CHIP_ID_YUKON_EC && \ | ||
68 | (hw)->chip_rev == CHIP_REV_YU_EC_A1) | ||
69 | #else | ||
70 | #define is_ec_a1(hw) 0 | ||
71 | #endif | ||
72 | |||
73 | #define RX_LE_SIZE 256 | ||
74 | #define MIN_RX_BUFFERS 8 | ||
75 | #define MAX_RX_BUFFERS 124 | ||
76 | #define RX_LE_BYTES (RX_LE_SIZE*sizeof(struct sky2_rx_le)) | ||
77 | |||
78 | #define TX_RING_SIZE 256 // min 64 max 4096 | ||
79 | #define STATUS_RING_SIZE 1024 // pow2 > (2*Rx + Tx) | ||
80 | #define STATUS_LE_BYTES (STATUS_RING_SIZE*sizeof(struct sky2_status_le)) | ||
81 | #define ETH_JUMBO_MTU 9000 | ||
82 | #define TX_WATCHDOG (5 * HZ) | ||
83 | #define NAPI_WEIGHT 64 | ||
84 | #define PHY_RETRIES 1000 | ||
85 | |||
86 | static const u32 default_msg = | ||
87 | NETIF_MSG_DRV| NETIF_MSG_PROBE| NETIF_MSG_LINK | ||
88 | | NETIF_MSG_TIMER | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR | ||
89 | | NETIF_MSG_IFUP| NETIF_MSG_IFDOWN; | ||
90 | |||
91 | static int debug = -1; /* defaults above */ | ||
92 | module_param(debug, int, 0); | ||
93 | MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); | ||
94 | |||
95 | static const struct pci_device_id sky2_id_table[] = { | ||
96 | { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) }, | ||
97 | { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b00) }, | ||
98 | { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) }, | ||
99 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4340) }, | ||
100 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4341) }, | ||
101 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4342) }, | ||
102 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4343) }, | ||
103 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4344) }, | ||
104 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4345) }, | ||
105 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4346) }, | ||
106 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4347) }, | ||
107 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4350) }, | ||
108 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4351) }, | ||
109 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4360) }, | ||
110 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4361) }, | ||
111 | { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4362) }, | ||
112 | { 0 } | ||
113 | }; | ||
114 | MODULE_DEVICE_TABLE(pci, sky2_id_table); | ||
115 | |||
116 | /* Avoid conditionals by using array */ | ||
117 | static const unsigned txqaddr[] = { Q_XA1, Q_XA2 }; | ||
118 | static const unsigned rxqaddr[] = { Q_R1, Q_R2 }; | ||
119 | |||
120 | static inline const char *chip_name(u8 chip_id) | ||
121 | { | ||
122 | switch (chip_id) { | ||
123 | case CHIP_ID_GENESIS: | ||
124 | return "Genesis"; | ||
125 | case CHIP_ID_YUKON: | ||
126 | return "Yukon"; | ||
127 | case CHIP_ID_YUKON_LITE: | ||
128 | return "Yukon-Lite"; | ||
129 | case CHIP_ID_YUKON_LP: | ||
130 | return "Yukon-LP"; | ||
131 | case CHIP_ID_YUKON_XL: | ||
132 | return "Yukon-XL"; | ||
133 | case CHIP_ID_YUKON_EC: | ||
134 | return "Yukon-EC"; | ||
135 | case CHIP_ID_YUKON_FE: | ||
136 | return "Yukon-FE"; | ||
137 | default: | ||
138 | return "???"; | ||
139 | } | ||
140 | } | ||
141 | |||
142 | static void gm_phy_write(struct sky2_hw *hw, unsigned port, u16 reg, u16 val) | ||
143 | { | ||
144 | int i; | ||
145 | |||
146 | gma_write16(hw, port, GM_SMI_DATA, val); | ||
147 | gma_write16(hw, port, GM_SMI_CTRL, | ||
148 | GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) | GM_SMI_CT_REG_AD(reg)); | ||
149 | |||
150 | for (i = 0; i < PHY_RETRIES; i++) { | ||
151 | udelay(1); | ||
152 | |||
153 | if (!(gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_BUSY)) | ||
154 | break; | ||
155 | } | ||
156 | } | ||
157 | |||
158 | static u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg) | ||
159 | { | ||
160 | int i; | ||
161 | |||
162 | gma_write16(hw, port, GM_SMI_CTRL, | ||
163 | GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) | ||
164 | | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD); | ||
165 | |||
166 | for (i = 0; i < PHY_RETRIES; i++) { | ||
167 | udelay(1); | ||
168 | if (gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_RD_VAL) | ||
169 | goto ready; | ||
170 | } | ||
171 | |||
172 | printk(KERN_WARNING PFX "%s: phy read timeout\n", | ||
173 | hw->dev[port]->name); | ||
174 | ready: | ||
175 | return gma_read16(hw, port, GM_SMI_DATA); | ||
176 | } | ||
177 | |||
178 | static void sky2_phy_reset(struct sky2_hw *hw, unsigned port) | ||
179 | { | ||
180 | u16 reg; | ||
181 | |||
182 | /* disable all GMAC IRQ's */ | ||
183 | sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0); | ||
184 | /* disable PHY IRQs */ | ||
185 | gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0); | ||
186 | gma_write16(hw, port, GM_MC_ADDR_H1, 0); /* clear MC hash */ | ||
187 | gma_write16(hw, port, GM_MC_ADDR_H2, 0); | ||
188 | gma_write16(hw, port, GM_MC_ADDR_H3, 0); | ||
189 | gma_write16(hw, port, GM_MC_ADDR_H4, 0); | ||
190 | |||
191 | reg = gma_read16(hw, port, GM_RX_CTRL); | ||
192 | reg |= GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA; | ||
193 | gma_write16(hw, port, GM_RX_CTRL, reg); | ||
194 | } | ||
195 | |||
196 | static void sky2_phy_init(struct sky2_hw *hw, unsigned port) | ||
197 | { | ||
198 | struct sky2_port *sky2 = netdev_priv(hw->dev[port]); | ||
199 | u16 ctrl, ct1000, adv; | ||
200 | u16 ledctrl, ledover; | ||
201 | |||
202 | pr_debug("phy reset autoneg=%s advertising=0x%x pause rx=%s tx=%s\n", | ||
203 | sky2->autoneg == AUTONEG_ENABLE ? "enable" : "disable", | ||
204 | sky2->advertising, | ||
205 | sky2->rx_pause ? "on" : "off", | ||
206 | sky2->tx_pause ? "on" : "off"); | ||
207 | |||
208 | if (sky2->autoneg == AUTONEG_ENABLE && | ||
209 | hw->chip_id != CHIP_ID_YUKON_XL) { | ||
210 | u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL); | ||
211 | |||
212 | ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK | | ||
213 | PHY_M_EC_MAC_S_MSK); | ||
214 | ectrl |= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ); | ||
215 | |||
216 | if (hw->chip_id == CHIP_ID_YUKON_EC) | ||
217 | ectrl |= PHY_M_EC_DSC_2(2) | PHY_M_EC_DOWN_S_ENA; | ||
218 | else | ||
219 | ectrl |= PHY_M_EC_M_DSC(2) | PHY_M_EC_S_DSC(3); | ||
220 | |||
221 | gm_phy_write(hw, port, PHY_MARV_EXT_CTRL, ectrl); | ||
222 | } | ||
223 | |||
224 | ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL); | ||
225 | if (hw->copper) { | ||
226 | if (hw->chip_id == CHIP_ID_YUKON_FE) { | ||
227 | /* enable automatic crossover */ | ||
228 | ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO) >> 1; | ||
229 | } else { | ||
230 | /* disable energy detect */ | ||
231 | ctrl &= ~PHY_M_PC_EN_DET_MSK; | ||
232 | |||
233 | /* enable automatic crossover */ | ||
234 | ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO); | ||
235 | |||
236 | if (sky2->autoneg == AUTONEG_ENABLE && | ||
237 | hw->chip_id == CHIP_ID_YUKON_XL) { | ||
238 | ctrl &= ~PHY_M_PC_DSC_MSK; | ||
239 | ctrl |= PHY_M_PC_DSC(2) | PHY_M_PC_DOWN_S_ENA; | ||
240 | } | ||
241 | } | ||
242 | gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); | ||
243 | } else { | ||
244 | /* workaround for deviation #4.88 (CRC errors) */ | ||
245 | /* disable Automatic Crossover */ | ||
246 | |||
247 | ctrl &= ~PHY_M_PC_MDIX_MSK; | ||
248 | gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); | ||
249 | |||
250 | if (hw->chip_id == CHIP_ID_YUKON_XL) { | ||
251 | /* Fiber: select 1000BASE-X only mode MAC Specific Ctrl Reg. */ | ||
252 | gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2); | ||
253 | ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL); | ||
254 | ctrl &= ~PHY_M_MAC_MD_MSK; | ||
255 | ctrl |= PHY_M_MAC_MODE_SEL(PHY_M_MAC_MD_1000BX); | ||
256 | gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); | ||
257 | |||
258 | /* select page 1 to access Fiber registers */ | ||
259 | gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 1); | ||
260 | } | ||
261 | |||
262 | ctrl &= ~(PHY_M_PC_MDIX_MSK | PHY_M_MAC_MD_MSK); | ||
263 | ctrl |= PHY_M_MAC_MODE_SEL(PHY_M_MAC_MD_1000BX); | ||
264 | } | ||
265 | |||
266 | ctrl = gm_phy_read(hw, port, PHY_MARV_CTRL); | ||
267 | if (sky2->autoneg == AUTONEG_DISABLE) | ||
268 | ctrl &= ~PHY_CT_ANE; | ||
269 | else | ||
270 | ctrl |= PHY_CT_ANE; | ||
271 | |||
272 | ctrl |= PHY_CT_RESET; | ||
273 | gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl); | ||
274 | |||
275 | ctrl = 0; | ||
276 | ct1000 = 0; | ||
277 | adv = PHY_AN_CSMA; | ||
278 | |||
279 | if (sky2->autoneg == AUTONEG_ENABLE) { | ||
280 | if (hw->copper) { | ||
281 | if (sky2->advertising & ADVERTISED_1000baseT_Full) | ||
282 | ct1000 |= PHY_M_1000C_AFD; | ||
283 | if (sky2->advertising & ADVERTISED_1000baseT_Half) | ||
284 | ct1000 |= PHY_M_1000C_AHD; | ||
285 | if (sky2->advertising & ADVERTISED_100baseT_Full) | ||
286 | adv |= PHY_M_AN_100_FD; | ||
287 | if (sky2->advertising & ADVERTISED_100baseT_Half) | ||
288 | adv |= PHY_M_AN_100_HD; | ||
289 | if (sky2->advertising & ADVERTISED_10baseT_Full) | ||
290 | adv |= PHY_M_AN_10_FD; | ||
291 | if (sky2->advertising & ADVERTISED_10baseT_Half) | ||
292 | adv |= PHY_M_AN_10_HD; | ||
293 | } else /* special defines for FIBER (88E1011S only) */ | ||
294 | adv |= PHY_M_AN_1000X_AHD | PHY_M_AN_1000X_AFD; | ||
295 | |||
296 | /* Set Flow-control capabilities */ | ||
297 | if (sky2->tx_pause && sky2->rx_pause) | ||
298 | adv |= PHY_AN_PAUSE_CAP; /* symmetric */ | ||
299 | else if (sky2->rx_pause && !sky2->tx_pause) | ||
300 | adv |= PHY_AN_PAUSE_ASYM|PHY_AN_PAUSE_CAP; | ||
301 | else if (!sky2->rx_pause && sky2->tx_pause) | ||
302 | adv |= PHY_AN_PAUSE_ASYM; /* local */ | ||
303 | |||
304 | /* Restart Auto-negotiation */ | ||
305 | ctrl |= PHY_CT_ANE | PHY_CT_RE_CFG; | ||
306 | } else { | ||
307 | /* forced speed/duplex settings */ | ||
308 | ct1000 = PHY_M_1000C_MSE; | ||
309 | |||
310 | if (sky2->duplex == DUPLEX_FULL) | ||
311 | ctrl |= PHY_CT_DUP_MD; | ||
312 | |||
313 | switch (sky2->speed) { | ||
314 | case SPEED_1000: | ||
315 | ctrl |= PHY_CT_SP1000; | ||
316 | break; | ||
317 | case SPEED_100: | ||
318 | ctrl |= PHY_CT_SP100; | ||
319 | break; | ||
320 | } | ||
321 | |||
322 | ctrl |= PHY_CT_RESET; | ||
323 | } | ||
324 | |||
325 | if (hw->chip_id != CHIP_ID_YUKON_FE) | ||
326 | gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, ct1000); | ||
327 | |||
328 | gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, adv); | ||
329 | gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl); | ||
330 | |||
331 | /* Setup Phy LED's */ | ||
332 | ledctrl = PHY_M_LED_PULS_DUR(PULS_170MS); | ||
333 | ledover = 0; | ||
334 | |||
335 | switch (hw->chip_id) { | ||
336 | case CHIP_ID_YUKON_FE: | ||
337 | /* on 88E3082 these bits are at 11..9 (shifted left) */ | ||
338 | ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) << 1; | ||
339 | |||
340 | ctrl = gm_phy_read(hw, port, PHY_MARV_FE_LED_PAR); | ||
341 | |||
342 | /* delete ACT LED control bits */ | ||
343 | ctrl &= ~PHY_M_FELP_LED1_MSK; | ||
344 | /* change ACT LED control to blink mode */ | ||
345 | ctrl |= PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_ACT_BL); | ||
346 | gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl); | ||
347 | break; | ||
348 | |||
349 | case CHIP_ID_YUKON_XL: | ||
350 | ctrl = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); | ||
351 | |||
352 | /* select page 3 to access LED control register */ | ||
353 | gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); | ||
354 | |||
355 | /* set LED Function Control register */ | ||
356 | gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, | ||
357 | (PHY_M_LEDC_LOS_CTRL(1) | /* LINK/ACT */ | ||
358 | PHY_M_LEDC_INIT_CTRL(7) | /* 10 Mbps */ | ||
359 | PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */ | ||
360 | PHY_M_LEDC_STA0_CTRL(7))); /* 1000 Mbps */ | ||
361 | |||
362 | /* set Polarity Control register */ | ||
363 | gm_phy_write(hw, port, PHY_MARV_PHY_STAT, | ||
364 | (PHY_M_POLC_LS1_P_MIX(4) | PHY_M_POLC_IS0_P_MIX(4) | | ||
365 | PHY_M_POLC_LOS_CTRL(2) | PHY_M_POLC_INIT_CTRL(2) | | ||
366 | PHY_M_POLC_STA1_CTRL(2) | PHY_M_POLC_STA0_CTRL(2))); | ||
367 | |||
368 | /* restore page register */ | ||
369 | gm_phy_write(hw, port, PHY_MARV_EXT_ADR, ctrl); | ||
370 | break; | ||
371 | |||
372 | default: | ||
373 | /* set Tx LED (LED_TX) to blink mode on Rx OR Tx activity */ | ||
374 | ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) | PHY_M_LEDC_TX_CTRL; | ||
375 | /* turn off the Rx LED (LED_RX) */ | ||
376 | ledover |= PHY_M_LED_MO_RX(MO_LED_OFF); | ||
377 | } | ||
378 | |||
379 | gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl); | ||
380 | |||
381 | if (sky2->autoneg == AUTONEG_DISABLE || sky2->speed == SPEED_100) { | ||
382 | /* turn on 100 Mbps LED (LED_LINK100) */ | ||
383 | ledover |= PHY_M_LED_MO_100(MO_LED_ON); | ||
384 | } | ||
385 | |||
386 | if (ledover) | ||
387 | gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover); | ||
388 | |||
389 | /* Enable phy interrupt on autonegotiation complete (or link up) */ | ||
390 | if (sky2->autoneg == AUTONEG_ENABLE) | ||
391 | gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_COMPL); | ||
392 | else | ||
393 | gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK); | ||
394 | } | ||
395 | |||
396 | static void sky2_mac_init(struct sky2_hw *hw, unsigned port) | ||
397 | { | ||
398 | struct sky2_port *sky2 = netdev_priv(hw->dev[port]); | ||
399 | u16 reg; | ||
400 | int i; | ||
401 | const u8 *addr = hw->dev[port]->dev_addr; | ||
402 | |||
403 | sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET); | ||
404 | sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR); | ||
405 | |||
406 | sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR); | ||
407 | |||
408 | if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 | ||
409 | && port == 1) { | ||
410 | /* WA DEV_472 -- looks like crossed wires on port 2 */ | ||
411 | /* clear GMAC 1 Control reset */ | ||
412 | sky2_write8(hw, SK_REG(0, GMAC_CTRL), GMC_RST_CLR); | ||
413 | do { | ||
414 | sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_SET); | ||
415 | sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_CLR); | ||
416 | } while (gm_phy_read(hw, 1, PHY_MARV_ID0) != PHY_MARV_ID0_VAL || | ||
417 | gm_phy_read(hw, 1, PHY_MARV_ID1) != PHY_MARV_ID1_Y2 || | ||
418 | gm_phy_read(hw, 1, PHY_MARV_INT_MASK) != 0); | ||
419 | } | ||
420 | |||
421 | |||
422 | if (sky2->autoneg == AUTONEG_DISABLE) { | ||
423 | reg = gma_read16(hw, port, GM_GP_CTRL); | ||
424 | reg |= GM_GPCR_AU_ALL_DIS; | ||
425 | gma_write16(hw, port, GM_GP_CTRL, reg); | ||
426 | gma_read16(hw, port, GM_GP_CTRL); | ||
427 | |||
428 | |||
429 | switch (sky2->speed) { | ||
430 | case SPEED_1000: | ||
431 | reg |= GM_GPCR_SPEED_1000; | ||
432 | /* fallthru */ | ||
433 | case SPEED_100: | ||
434 | reg |= GM_GPCR_SPEED_100; | ||
435 | } | ||
436 | |||
437 | if (sky2->duplex == DUPLEX_FULL) | ||
438 | reg |= GM_GPCR_DUP_FULL; | ||
439 | } else | ||
440 | reg = GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100 | GM_GPCR_DUP_FULL; | ||
441 | |||
442 | if (!sky2->tx_pause && !sky2->rx_pause) { | ||
443 | sky2_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF); | ||
444 | reg |= GM_GPCR_FC_TX_DIS | GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS; | ||
445 | } else if (sky2->tx_pause &&!sky2->rx_pause) { | ||
446 | /* disable Rx flow-control */ | ||
447 | reg |= GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS; | ||
448 | } | ||
449 | |||
450 | gma_write16(hw, port, GM_GP_CTRL, reg); | ||
451 | |||
452 | sky2_read16(hw, GMAC_IRQ_SRC); | ||
453 | |||
454 | spin_lock_bh(&hw->phy_lock); | ||
455 | sky2_phy_init(hw, port); | ||
456 | spin_unlock_bh(&hw->phy_lock); | ||
457 | |||
458 | /* MIB clear */ | ||
459 | reg = gma_read16(hw, port, GM_PHY_ADDR); | ||
460 | gma_write16(hw, port, GM_PHY_ADDR, reg | GM_PAR_MIB_CLR); | ||
461 | |||
462 | for (i = 0; i < GM_MIB_CNT_SIZE; i++) | ||
463 | gma_read16(hw, port, GM_MIB_CNT_BASE + 8*i); | ||
464 | gma_write16(hw, port, GM_PHY_ADDR, reg); | ||
465 | |||
466 | /* transmit control */ | ||
467 | gma_write16(hw, port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF)); | ||
468 | |||
469 | /* receive control reg: unicast + multicast + no FCS */ | ||
470 | gma_write16(hw, port, GM_RX_CTRL, | ||
471 | GM_RXCR_UCF_ENA | GM_RXCR_CRC_DIS | GM_RXCR_MCF_ENA); | ||
472 | |||
473 | /* transmit flow control */ | ||
474 | gma_write16(hw, port, GM_TX_FLOW_CTRL, 0xffff); | ||
475 | |||
476 | /* transmit parameter */ | ||
477 | gma_write16(hw, port, GM_TX_PARAM, | ||
478 | TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) | | ||
479 | TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) | | ||
480 | TX_IPG_JAM_DATA(TX_IPG_JAM_DEF) | | ||
481 | TX_BACK_OFF_LIM(TX_BOF_LIM_DEF)); | ||
482 | |||
483 | /* serial mode register */ | ||
484 | reg = DATA_BLIND_VAL(DATA_BLIND_DEF) | | ||
485 | GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF); | ||
486 | |||
487 | if (hw->dev[port]->mtu > 1500) | ||
488 | reg |= GM_SMOD_JUMBO_ENA; | ||
489 | |||
490 | gma_write16(hw, port, GM_SERIAL_MODE, reg); | ||
491 | |||
492 | /* physical address: used for pause frames */ | ||
493 | gma_set_addr(hw, port, GM_SRC_ADDR_1L, addr); | ||
494 | /* virtual address for data */ | ||
495 | gma_set_addr(hw, port, GM_SRC_ADDR_2L, addr); | ||
496 | |||
497 | /* enable interrupt mask for counter overflows */ | ||
498 | gma_write16(hw, port, GM_TX_IRQ_MSK, 0); | ||
499 | gma_write16(hw, port, GM_RX_IRQ_MSK, 0); | ||
500 | gma_write16(hw, port, GM_TR_IRQ_MSK, 0); | ||
501 | |||
502 | /* Configure Rx MAC FIFO */ | ||
503 | sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR); | ||
504 | sky2_write16(hw, SK_REG(port, RX_GMF_CTRL_T), | ||
505 | GMF_OPER_ON | GMF_RX_F_FL_ON); | ||
506 | |||
507 | reg = RX_FF_FL_DEF_MSK; | ||
508 | if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev <= 1) | ||
509 | reg = 0; /* WA Dev #4115 */ | ||
510 | |||
511 | sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), reg); | ||
512 | /* Set threshold to 0xa (64 bytes) | ||
513 | * ASF disabled so no need to do WA dev #4.30 | ||
514 | */ | ||
515 | sky2_write16(hw, SK_REG(port, RX_GMF_FL_THR), RX_GMF_FL_THR_DEF); | ||
516 | |||
517 | /* Configure Tx MAC FIFO */ | ||
518 | sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_CLR); | ||
519 | sky2_write16(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_OPER_ON); | ||
520 | |||
521 | /* Turn off Rx fifo flush (per sk98lin) */ | ||
522 | sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RX_F_FL_OFF); | ||
523 | } | ||
524 | |||
525 | static void sky2_ramset(struct sky2_hw *hw, u16 q, u32 start, size_t len) | ||
526 | { | ||
527 | u32 end; | ||
528 | |||
529 | start /= 8; | ||
530 | len /= 8; | ||
531 | end = start + len - 1; | ||
532 | pr_debug("ramset q=%d start=0x%x end=0x%x\n", q, start, end); | ||
533 | |||
534 | sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR); | ||
535 | sky2_write32(hw, RB_ADDR(q, RB_START), start); | ||
536 | sky2_write32(hw, RB_ADDR(q, RB_END), end); | ||
537 | sky2_write32(hw, RB_ADDR(q, RB_WP), start); | ||
538 | sky2_write32(hw, RB_ADDR(q, RB_RP), start); | ||
539 | |||
540 | if (q == Q_R1 || q == Q_R2) { | ||
541 | /* Set thresholds on receive queue's */ | ||
542 | sky2_write32(hw, RB_ADDR(q, RB_RX_UTPP), | ||
543 | start + (2*len)/3); | ||
544 | sky2_write32(hw, RB_ADDR(q, RB_RX_LTPP), | ||
545 | start + (len/3)); | ||
546 | } else { | ||
547 | /* Enable store & forward on Tx queue's because | ||
548 | * Tx FIFO is only 1K on Yukon | ||
549 | */ | ||
550 | sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_STFWD); | ||
551 | } | ||
552 | |||
553 | sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_OP_MD); | ||
554 | } | ||
555 | |||
556 | |||
557 | /* Setup Bus Memory Interface */ | ||
558 | static void sky2_qset(struct sky2_hw *hw, u16 q, u32 wm) | ||
559 | { | ||
560 | sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_RESET); | ||
561 | sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_OPER_INIT); | ||
562 | sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_FIFO_OP_ON); | ||
563 | sky2_write32(hw, Q_ADDR(q, Q_WM), wm); | ||
564 | } | ||
565 | |||
566 | |||
567 | /* Setup prefetch unit registers. This is the interface between | ||
568 | * hardware and driver list elements | ||
569 | */ | ||
570 | static inline void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr, | ||
571 | u64 addr, u32 last) | ||
572 | { | ||
573 | pr_debug("sky2 prefetch init q=%x addr=%llx last=%x\n", | ||
574 | Y2_QADDR(qaddr, 0), addr, last); | ||
575 | |||
576 | sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_SET); | ||
577 | sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_CLR); | ||
578 | sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), addr >> 32); | ||
579 | sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), (u32) addr); | ||
580 | sky2_write16(hw, Y2_QADDR(qaddr, PREF_UNIT_LAST_IDX), last); | ||
581 | sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_OP_ON); | ||
582 | } | ||
583 | |||
584 | |||
585 | /* | ||
586 | * This is a workaround code taken from syskonnect sk98lin driver | ||
587 | * to deal with chip bug in the wraparound case. | ||
588 | */ | ||
589 | static inline void sky2_put_idx(struct sky2_hw *hw, unsigned q, | ||
590 | u16 idx, u16 *last, u16 size) | ||
591 | |||
592 | { | ||
593 | BUG_ON(idx >= size); | ||
594 | |||
595 | wmb(); | ||
596 | if (is_ec_a1(hw) && idx < *last) { | ||
597 | u16 hwget = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX)); | ||
598 | |||
599 | if (hwget == 0) { | ||
600 | /* Start prefetching again */ | ||
601 | sky2_write8(hw, Y2_QADDR(q, PREF_UNIT_FIFO_WM), | ||
602 | 0xe0); | ||
603 | goto setnew; | ||
604 | } | ||
605 | |||
606 | if (hwget == size-1) { | ||
607 | /* set watermark to one list element */ | ||
608 | sky2_write8(hw, Y2_QADDR(q, PREF_UNIT_FIFO_WM), 8); | ||
609 | |||
610 | /* set put index to first list element */ | ||
611 | sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), 0); | ||
612 | } else /* have hardware go to end of list */ | ||
613 | sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), size-1); | ||
614 | } else { | ||
615 | setnew: | ||
616 | sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), idx); | ||
617 | *last = idx; | ||
618 | } | ||
619 | } | ||
620 | |||
621 | static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2) | ||
622 | { | ||
623 | struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put; | ||
624 | sky2->rx_put = (sky2->rx_put + 1) % RX_LE_SIZE; | ||
625 | return le; | ||
626 | } | ||
627 | |||
628 | static inline void sky2_rx_add(struct sky2_port *sky2, dma_addr_t map, u16 len) | ||
629 | { | ||
630 | struct sky2_rx_le *le; | ||
631 | |||
632 | if (sizeof(map) > sizeof(u32)) { | ||
633 | le = sky2_next_rx(sky2); | ||
634 | le->rx.addr = cpu_to_le32((u64) map >> 32); | ||
635 | le->ctrl = 0; | ||
636 | le->opcode = OP_ADDR64 | HW_OWNER; | ||
637 | } | ||
638 | |||
639 | le = sky2_next_rx(sky2); | ||
640 | le->rx.addr = cpu_to_le32((u32) map); | ||
641 | le->length = cpu_to_le16(len); | ||
642 | le->ctrl = 0; | ||
643 | le->opcode = OP_PACKET | HW_OWNER; | ||
644 | } | ||
645 | |||
646 | /* Tell chip where to start receive checksum. | ||
647 | * Actually has two checksums, but set both same to avoid possible byte | ||
648 | * order problems. | ||
649 | */ | ||
650 | static void sky2_rx_set_offset(struct sky2_port *sky2) | ||
651 | { | ||
652 | struct sky2_rx_le *le; | ||
653 | |||
654 | sky2_write32(sky2->hw, | ||
655 | Q_ADDR(rxqaddr[sky2->port], Q_CSR), | ||
656 | sky2->rx_csum ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM); | ||
657 | |||
658 | le = sky2_next_rx(sky2); | ||
659 | le->rx.csum.start1 = ETH_HLEN; | ||
660 | le->rx.csum.start2 = ETH_HLEN; | ||
661 | le->ctrl = 0; | ||
662 | le->opcode = OP_TCPSTART | HW_OWNER; | ||
663 | wmb(); | ||
664 | sky2_write16(sky2->hw, | ||
665 | Y2_QADDR(rxqaddr[sky2->port], PREF_UNIT_PUT_IDX), | ||
666 | sky2->rx_put); | ||
667 | |||
668 | } | ||
669 | |||
670 | /* Cleanout receive buffer area, assumes receiver hardware stopped */ | ||
671 | static void sky2_rx_clean(struct sky2_port *sky2) | ||
672 | { | ||
673 | unsigned i; | ||
674 | |||
675 | memset(sky2->rx_le, 0, RX_LE_BYTES); | ||
676 | for (i = 0; i < sky2->rx_ring_size; i++) { | ||
677 | struct ring_info *re = sky2->rx_ring + i; | ||
678 | |||
679 | if (re->skb) { | ||
680 | pci_unmap_single(sky2->hw->pdev, | ||
681 | pci_unmap_addr(re, mapaddr), | ||
682 | pci_unmap_len(re, maplen), | ||
683 | PCI_DMA_FROMDEVICE); | ||
684 | kfree_skb(re->skb); | ||
685 | re->skb = NULL; | ||
686 | } | ||
687 | } | ||
688 | } | ||
689 | |||
690 | static inline struct sk_buff *sky2_rx_alloc_skb(struct sky2_port *sky2, | ||
691 | unsigned int size, int gfp_mask) | ||
692 | { | ||
693 | struct sk_buff *skb; | ||
694 | |||
695 | skb = alloc_skb(size, gfp_mask); | ||
696 | if (likely(skb)) { | ||
697 | skb->dev = sky2->netdev; | ||
698 | skb_reserve(skb, NET_IP_ALIGN); | ||
699 | } | ||
700 | return skb; | ||
701 | } | ||
702 | |||
703 | /* | ||
704 | * Allocate and setup receiver buffer pool. | ||
705 | * In case of 64 bit dma, there are 2X as many list elements | ||
706 | * available as ring entries | ||
707 | * and need to reserve one list element so we don't wrap around. | ||
708 | */ | ||
709 | static int sky2_rx_fill(struct sky2_port *sky2) | ||
710 | { | ||
711 | unsigned i; | ||
712 | unsigned int rx_buf_size = sky2->netdev->mtu + ETH_HLEN + 8; | ||
713 | |||
714 | pr_debug("sky2_rx_fill %d\n", sky2->rx_ring_size); | ||
715 | for (i = 0; i < sky2->rx_ring_size; i++) { | ||
716 | struct ring_info *re = sky2->rx_ring + i; | ||
717 | dma_addr_t paddr; | ||
718 | |||
719 | re->skb = sky2_rx_alloc_skb(sky2, rx_buf_size, GFP_KERNEL); | ||
720 | if (!re->skb) | ||
721 | goto nomem; | ||
722 | |||
723 | paddr = pci_map_single(sky2->hw->pdev, re->skb->data, | ||
724 | rx_buf_size, PCI_DMA_FROMDEVICE); | ||
725 | |||
726 | pci_unmap_len_set(re, maplen, rx_buf_size); | ||
727 | pci_unmap_addr_set(re, mapaddr, paddr); | ||
728 | sky2_rx_add(sky2, paddr, rx_buf_size); | ||
729 | } | ||
730 | |||
731 | sky2_write16(sky2->hw, | ||
732 | Y2_QADDR(rxqaddr[sky2->port], PREF_UNIT_PUT_IDX), | ||
733 | sky2->rx_put); | ||
734 | |||
735 | return 0; | ||
736 | nomem: | ||
737 | sky2_rx_clean(sky2); | ||
738 | return -ENOMEM; | ||
739 | } | ||
740 | |||
741 | /* Bring up network interface. */ | ||
742 | static int sky2_up(struct net_device *dev) | ||
743 | { | ||
744 | struct sky2_port *sky2 = netdev_priv(dev); | ||
745 | struct sky2_hw *hw = sky2->hw; | ||
746 | unsigned port = sky2->port; | ||
747 | u32 ramsize, rxspace; | ||
748 | int err = -ENOMEM; | ||
749 | |||
750 | if (netif_msg_ifup(sky2)) | ||
751 | printk(KERN_INFO PFX "%s: enabling interface\n", dev->name); | ||
752 | |||
753 | /* must be power of 2 */ | ||
754 | sky2->tx_le = pci_alloc_consistent(hw->pdev, | ||
755 | TX_RING_SIZE * sizeof(struct sky2_tx_le), | ||
756 | &sky2->tx_le_map); | ||
757 | if (!sky2->tx_le) | ||
758 | goto err_out; | ||
759 | |||
760 | sky2->tx_ring = kmalloc(TX_RING_SIZE * sizeof(struct ring_info), | ||
761 | GFP_KERNEL); | ||
762 | if (!sky2->tx_ring) | ||
763 | goto err_out; | ||
764 | sky2->tx_prod = sky2->tx_cons = 0; | ||
765 | memset(sky2->tx_ring, 0, TX_RING_SIZE * sizeof(struct ring_info)); | ||
766 | |||
767 | sky2->rx_le = pci_alloc_consistent(hw->pdev, RX_LE_BYTES, | ||
768 | &sky2->rx_le_map); | ||
769 | if (!sky2->rx_le) | ||
770 | goto err_out; | ||
771 | memset(sky2->rx_le, 0, RX_LE_BYTES); | ||
772 | |||
773 | sky2->rx_ring = kmalloc(sky2->rx_ring_size * sizeof(struct ring_info), | ||
774 | GFP_KERNEL); | ||
775 | if (!sky2->rx_ring) | ||
776 | goto err_out; | ||
777 | |||
778 | sky2_mac_init(hw, port); | ||
779 | |||
780 | /* Configure RAM buffers */ | ||
781 | if (hw->chip_id == CHIP_ID_YUKON_FE || | ||
782 | (hw->chip_id == CHIP_ID_YUKON_EC && hw->chip_rev == 2)) | ||
783 | ramsize = 4096; | ||
784 | else { | ||
785 | u8 e0 = sky2_read8(hw, B2_E_0); | ||
786 | ramsize = (e0 == 0) ? (128*1024) : (e0 * 4096); | ||
787 | } | ||
788 | |||
789 | /* 2/3 for Rx */ | ||
790 | rxspace = (2 * ramsize) / 3; | ||
791 | sky2_ramset(hw, rxqaddr[port], 0, rxspace); | ||
792 | sky2_ramset(hw, txqaddr[port], rxspace, ramsize - rxspace); | ||
793 | |||
794 | sky2_qset(hw, rxqaddr[port], is_pciex(hw) ? 0x80 : 0x600); | ||
795 | sky2_qset(hw, txqaddr[port], 0x600); | ||
796 | |||
797 | sky2->rx_put = sky2->rx_next = 0; | ||
798 | sky2_prefetch_init(hw, rxqaddr[port], sky2->rx_le_map, RX_LE_SIZE-1); | ||
799 | |||
800 | sky2_rx_set_offset(sky2); | ||
801 | |||
802 | err = sky2_rx_fill(sky2); | ||
803 | if (err) | ||
804 | goto err_out; | ||
805 | |||
806 | sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map, | ||
807 | TX_RING_SIZE - 1); | ||
808 | |||
809 | /* Enable interrupts from phy/mac for port */ | ||
810 | hw->intr_mask |= (port == 0) ? Y2_IS_PORT_1 : Y2_IS_PORT_2; | ||
811 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
812 | return 0; | ||
813 | |||
814 | err_out: | ||
815 | if (sky2->rx_le) | ||
816 | pci_free_consistent(hw->pdev, RX_LE_BYTES, | ||
817 | sky2->rx_le, sky2->rx_le_map); | ||
818 | if (sky2->tx_le) | ||
819 | pci_free_consistent(hw->pdev, | ||
820 | TX_RING_SIZE * sizeof(struct sky2_tx_le), | ||
821 | sky2->tx_le, sky2->tx_le_map); | ||
822 | if (sky2->tx_ring) | ||
823 | kfree(sky2->tx_ring); | ||
824 | if (sky2->rx_ring) | ||
825 | kfree(sky2->rx_ring); | ||
826 | |||
827 | return err; | ||
828 | } | ||
829 | |||
830 | /* | ||
831 | * Worst case number of list elements is 36 | ||
832 | * TSO + CHKSUM + ADDR64 + BUFFER + (ADDR+BUFFER)*MAXFRAGS | ||
833 | */ | ||
834 | #define MAX_SKB_TX_LE (4 + 2*MAX_SKB_FRAGS) | ||
835 | |||
836 | static inline int sky2_xmit_avail(const struct sky2_port *sky2) | ||
837 | { | ||
838 | return (sky2->tx_cons > sky2->tx_prod ? 0 : TX_RING_SIZE) | ||
839 | + sky2->tx_cons - sky2->tx_prod - 1; | ||
840 | } | ||
841 | |||
842 | static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2) | ||
843 | { | ||
844 | struct sky2_tx_le *le = sky2->tx_le + sky2->tx_prod; | ||
845 | sky2->tx_prod = (sky2->tx_prod + 1) % TX_RING_SIZE; | ||
846 | return le; | ||
847 | } | ||
848 | |||
849 | /* Put one frame in ring for transmit. */ | ||
850 | static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev) | ||
851 | { | ||
852 | struct sky2_port *sky2 = netdev_priv(dev); | ||
853 | struct sky2_hw *hw = sky2->hw; | ||
854 | struct sky2_tx_le *le; | ||
855 | struct ring_info *re; | ||
856 | unsigned i, len; | ||
857 | dma_addr_t mapping; | ||
858 | u32 addr64; | ||
859 | u16 mss; | ||
860 | u8 ctrl; | ||
861 | |||
862 | skb = skb_padto(skb, ETH_ZLEN); | ||
863 | if (!skb) | ||
864 | return NETDEV_TX_OK; | ||
865 | |||
866 | if (!spin_trylock(&sky2->tx_lock)) | ||
867 | return NETDEV_TX_LOCKED; | ||
868 | |||
869 | if (unlikely(sky2_xmit_avail(sky2) < MAX_SKB_TX_LE)) { | ||
870 | netif_stop_queue(dev); | ||
871 | spin_unlock(&sky2->tx_lock); | ||
872 | |||
873 | printk(KERN_WARNING PFX "%s: ring full when queue awake!\n", | ||
874 | dev->name); | ||
875 | return NETDEV_TX_BUSY; | ||
876 | } | ||
877 | |||
878 | if (netif_msg_tx_queued(sky2)) | ||
879 | printk(KERN_DEBUG "%s: tx queued, slot %u, len %d\n", | ||
880 | dev->name, sky2->tx_prod, skb->len); | ||
881 | |||
882 | |||
883 | len = skb_headlen(skb); | ||
884 | mapping = pci_map_single(hw->pdev, skb->data, len, PCI_DMA_TODEVICE); | ||
885 | |||
886 | /* Check for TCP Segmentation Offload */ | ||
887 | mss = skb_shinfo(skb)->tso_size; | ||
888 | if (mss) { | ||
889 | /* just drop the packet if non-linear expansion fails */ | ||
890 | if (skb_header_cloned(skb) && | ||
891 | pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) { | ||
892 | dev_kfree_skb(skb); | ||
893 | return NETDEV_TX_OK; | ||
894 | } | ||
895 | |||
896 | mss += ((skb->h.th->doff - 5) * 4); /* TCP options */ | ||
897 | mss += (skb->nh.iph->ihl * 4) + sizeof(struct tcphdr); | ||
898 | mss += ETH_HLEN; | ||
899 | |||
900 | le = get_tx_le(sky2); | ||
901 | le->tx.tso.size = cpu_to_le16(mss); | ||
902 | le->ctrl = 0; | ||
903 | le->opcode = OP_LRGLEN | HW_OWNER; | ||
904 | } | ||
905 | |||
906 | /* Handle Hi DMA */ | ||
907 | if (sizeof(mapping) > sizeof(u32)) { | ||
908 | addr64 = (u64)mapping >> 32; | ||
909 | |||
910 | le = get_tx_le(sky2); | ||
911 | le->tx.addr = cpu_to_le32(addr64); | ||
912 | le->ctrl = 0; | ||
913 | le->opcode = OP_ADDR64 | HW_OWNER; | ||
914 | } | ||
915 | |||
916 | /* Handle TCP checksum offload */ | ||
917 | ctrl = 0; | ||
918 | if (skb->ip_summed == CHECKSUM_HW) { | ||
919 | ptrdiff_t hdr = skb->h.raw - skb->data; | ||
920 | |||
921 | ctrl = CALSUM | WR_SUM | INIT_SUM | LOCK_SUM; | ||
922 | if (skb->nh.iph->protocol == IPPROTO_UDP) | ||
923 | ctrl |= UDPTCP; | ||
924 | |||
925 | le = get_tx_le(sky2); | ||
926 | le->tx.csum.start = cpu_to_le16(hdr); | ||
927 | le->tx.csum.offset = cpu_to_le16(hdr + skb->csum); | ||
928 | le->length = 0; | ||
929 | le->ctrl = 1; /* one packet */ | ||
930 | le->opcode = OP_TCPLISW|HW_OWNER; | ||
931 | } | ||
932 | |||
933 | le = get_tx_le(sky2); | ||
934 | le->tx.addr = cpu_to_le32((u32) mapping); | ||
935 | le->length = cpu_to_le16(len); | ||
936 | le->ctrl = ctrl; | ||
937 | le->opcode = (mss ? OP_LARGESEND : OP_PACKET) |HW_OWNER; | ||
938 | |||
939 | re = &sky2->tx_ring[le - sky2->tx_le]; | ||
940 | re->skb = skb; | ||
941 | pci_unmap_addr_set(re, mapaddr, mapping); | ||
942 | pci_unmap_len_set(re, maplen, len); | ||
943 | |||
944 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { | ||
945 | skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; | ||
946 | |||
947 | mapping = pci_map_page(hw->pdev, frag->page, frag->page_offset, | ||
948 | frag->size, PCI_DMA_TODEVICE); | ||
949 | |||
950 | if (sizeof(mapping) > sizeof(u32)) { | ||
951 | u32 hi = (u64) mapping >> 32; | ||
952 | if (hi != addr64) { | ||
953 | le = get_tx_le(sky2); | ||
954 | le->tx.addr = cpu_to_le32(hi); | ||
955 | le->ctrl = 0; | ||
956 | le->opcode = OP_ADDR64|HW_OWNER; | ||
957 | addr64 = hi; | ||
958 | } | ||
959 | } | ||
960 | |||
961 | le = get_tx_le(sky2); | ||
962 | le->tx.addr = cpu_to_le32((u32) mapping); | ||
963 | le->length = cpu_to_le16(frag->size); | ||
964 | le->ctrl = ctrl; | ||
965 | le->opcode = OP_BUFFER|HW_OWNER; | ||
966 | |||
967 | re = &sky2->tx_ring[le - sky2->tx_le]; | ||
968 | pci_unmap_addr_set(re, mapaddr, mapping); | ||
969 | pci_unmap_len_set(re, maplen, frag->size); | ||
970 | } | ||
971 | |||
972 | le->ctrl |= EOP; | ||
973 | |||
974 | sky2_put_idx(sky2->hw, txqaddr[sky2->port], sky2->tx_prod, | ||
975 | &sky2->tx_last_put, TX_RING_SIZE); | ||
976 | |||
977 | if (sky2_xmit_avail(sky2) < MAX_SKB_TX_LE) { | ||
978 | pr_debug("%s: transmit queue full\n", dev->name); | ||
979 | netif_stop_queue(dev); | ||
980 | } | ||
981 | spin_unlock(&sky2->tx_lock); | ||
982 | |||
983 | dev->trans_start = jiffies; | ||
984 | return NETDEV_TX_OK; | ||
985 | } | ||
986 | |||
987 | |||
988 | /* | ||
989 | * Free ring elements from starting at tx_cons until done | ||
990 | * This unwinds the elements based on the usage assigned | ||
991 | * xmit routine. | ||
992 | */ | ||
993 | static void sky2_tx_complete(struct net_device *dev, u16 done) | ||
994 | { | ||
995 | struct sky2_port *sky2 = netdev_priv(dev); | ||
996 | unsigned idx = sky2->tx_cons; | ||
997 | struct sk_buff *skb = NULL; | ||
998 | |||
999 | BUG_ON(done >= TX_RING_SIZE); | ||
1000 | |||
1001 | spin_lock(&sky2->tx_lock); | ||
1002 | while (idx != done) { | ||
1003 | struct ring_info *re = sky2->tx_ring + idx; | ||
1004 | struct sky2_tx_le *le = sky2->tx_le + idx; | ||
1005 | |||
1006 | BUG_ON(le->opcode == 0); | ||
1007 | |||
1008 | switch(le->opcode & ~HW_OWNER) { | ||
1009 | case OP_LARGESEND: | ||
1010 | case OP_PACKET: | ||
1011 | if (skb) | ||
1012 | dev_kfree_skb_any(skb); | ||
1013 | skb = re->skb; | ||
1014 | BUG_ON(!skb); | ||
1015 | re->skb = NULL; | ||
1016 | |||
1017 | pci_unmap_single(sky2->hw->pdev, | ||
1018 | pci_unmap_addr(re, mapaddr), | ||
1019 | pci_unmap_len(re, maplen), | ||
1020 | PCI_DMA_TODEVICE); | ||
1021 | break; | ||
1022 | |||
1023 | case OP_BUFFER: | ||
1024 | pci_unmap_page(sky2->hw->pdev, | ||
1025 | pci_unmap_addr(re, mapaddr), | ||
1026 | pci_unmap_len(re, maplen), | ||
1027 | PCI_DMA_TODEVICE); | ||
1028 | break; | ||
1029 | } | ||
1030 | |||
1031 | le->opcode = 0; | ||
1032 | idx = (idx + 1) % TX_RING_SIZE; | ||
1033 | } | ||
1034 | |||
1035 | if (skb) | ||
1036 | dev_kfree_skb_any(skb); | ||
1037 | sky2->tx_cons = idx; | ||
1038 | |||
1039 | if (sky2_xmit_avail(sky2) > MAX_SKB_TX_LE) | ||
1040 | netif_wake_queue(dev); | ||
1041 | spin_unlock(&sky2->tx_lock); | ||
1042 | } | ||
1043 | |||
1044 | /* Cleanup all untransmitted buffers, assume transmitter not running */ | ||
1045 | static inline void sky2_tx_clean(struct sky2_port *sky2) | ||
1046 | { | ||
1047 | sky2_tx_complete(sky2->netdev, sky2->tx_prod); | ||
1048 | } | ||
1049 | |||
1050 | /* Network shutdown */ | ||
1051 | static int sky2_down(struct net_device *dev) | ||
1052 | { | ||
1053 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1054 | struct sky2_hw *hw = sky2->hw; | ||
1055 | unsigned port = sky2->port; | ||
1056 | u16 ctrl; | ||
1057 | int i; | ||
1058 | |||
1059 | if (netif_msg_ifdown(sky2)) | ||
1060 | printk(KERN_INFO PFX "%s: disabling interface\n", dev->name); | ||
1061 | |||
1062 | netif_stop_queue(dev); | ||
1063 | |||
1064 | /* Stop transmitter */ | ||
1065 | sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_STOP); | ||
1066 | sky2_read32(hw, Q_ADDR(txqaddr[port], Q_CSR)); | ||
1067 | |||
1068 | sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), | ||
1069 | RB_RST_SET|RB_DIS_OP_MD); | ||
1070 | |||
1071 | ctrl = gma_read16(hw, port, GM_GP_CTRL); | ||
1072 | ctrl &= ~(GM_GPCR_TX_ENA|GM_GPCR_RX_ENA); | ||
1073 | gma_write16(hw, port, GM_GP_CTRL, ctrl); | ||
1074 | |||
1075 | sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET); | ||
1076 | |||
1077 | /* Workaround shared GMAC reset */ | ||
1078 | if (! (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 | ||
1079 | && port == 0 && hw->dev[1] && netif_running(hw->dev[1]))) | ||
1080 | sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET); | ||
1081 | |||
1082 | /* Disable Force Sync bit and Enable Alloc bit */ | ||
1083 | sky2_write8(hw, SK_REG(port, TXA_CTRL), | ||
1084 | TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC); | ||
1085 | |||
1086 | /* Stop Interval Timer and Limit Counter of Tx Arbiter */ | ||
1087 | sky2_write32(hw, SK_REG(port, TXA_ITI_INI), 0L); | ||
1088 | sky2_write32(hw, SK_REG(port, TXA_LIM_INI), 0L); | ||
1089 | |||
1090 | /* Reset the PCI FIFO of the async Tx queue */ | ||
1091 | sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_RST_SET | BMU_FIFO_RST); | ||
1092 | |||
1093 | /* Reset the Tx prefetch units */ | ||
1094 | sky2_write32(hw, Y2_QADDR(txqaddr[port], PREF_UNIT_CTRL), | ||
1095 | PREF_UNIT_RST_SET); | ||
1096 | |||
1097 | sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), RB_RST_SET); | ||
1098 | |||
1099 | /* | ||
1100 | * The RX Stop command will not work for Yukon-2 if the BMU does not | ||
1101 | * reach the end of packet and since we can't make sure that we have | ||
1102 | * incoming data, we must reset the BMU while it is not doing a DMA | ||
1103 | * transfer. Since it is possible that the RX path is still active, | ||
1104 | * the RX RAM buffer will be stopped first, so any possible incoming | ||
1105 | * data will not trigger a DMA. After the RAM buffer is stopped, the | ||
1106 | * BMU is polled until any DMA in progress is ended and only then it | ||
1107 | * will be reset. | ||
1108 | */ | ||
1109 | |||
1110 | /* disable the RAM Buffer receive queue */ | ||
1111 | sky2_write8(hw, RB_ADDR(rxqaddr[port], RB_CTRL), RB_DIS_OP_MD); | ||
1112 | |||
1113 | for (i = 0; i < 0xffff; i++) | ||
1114 | if (sky2_read8(hw, RB_ADDR(rxqaddr[port], Q_RSL)) | ||
1115 | == sky2_read8(hw, RB_ADDR(rxqaddr[port], Q_RL))) | ||
1116 | break; | ||
1117 | |||
1118 | sky2_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), | ||
1119 | BMU_RST_SET | BMU_FIFO_RST); | ||
1120 | /* reset the Rx prefetch unit */ | ||
1121 | sky2_write32(hw, Y2_QADDR(rxqaddr[port], PREF_UNIT_CTRL), | ||
1122 | PREF_UNIT_RST_SET); | ||
1123 | |||
1124 | sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET); | ||
1125 | sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET); | ||
1126 | |||
1127 | /* turn off led's */ | ||
1128 | sky2_write16(hw, B0_Y2LED, LED_STAT_OFF); | ||
1129 | |||
1130 | sky2_tx_clean(sky2); | ||
1131 | sky2_rx_clean(sky2); | ||
1132 | |||
1133 | pci_free_consistent(hw->pdev, RX_LE_BYTES, | ||
1134 | sky2->rx_le, sky2->rx_le_map); | ||
1135 | kfree(sky2->rx_ring); | ||
1136 | |||
1137 | pci_free_consistent(hw->pdev, | ||
1138 | TX_RING_SIZE * sizeof(struct sky2_tx_le), | ||
1139 | sky2->tx_le, sky2->tx_le_map); | ||
1140 | kfree(sky2->tx_ring); | ||
1141 | |||
1142 | return 0; | ||
1143 | } | ||
1144 | |||
1145 | static u16 sky2_phy_speed(const struct sky2_hw *hw, u16 aux) | ||
1146 | { | ||
1147 | if (hw->chip_id == CHIP_ID_YUKON_FE) | ||
1148 | return (aux & PHY_M_PS_SPEED_100) ? SPEED_100 : SPEED_10; | ||
1149 | |||
1150 | switch (aux & PHY_M_PS_SPEED_MSK) { | ||
1151 | case PHY_M_PS_SPEED_1000: | ||
1152 | return SPEED_1000; | ||
1153 | case PHY_M_PS_SPEED_100: | ||
1154 | return SPEED_100; | ||
1155 | default: | ||
1156 | return SPEED_10; | ||
1157 | } | ||
1158 | } | ||
1159 | |||
1160 | static void sky2_link_up(struct sky2_port *sky2) | ||
1161 | { | ||
1162 | struct sky2_hw *hw = sky2->hw; | ||
1163 | unsigned port = sky2->port; | ||
1164 | u16 reg; | ||
1165 | |||
1166 | /* Enable Transmit FIFO Underrun */ | ||
1167 | sky2_write8(hw, GMAC_IRQ_MSK, GMAC_DEF_MSK); | ||
1168 | |||
1169 | reg = gma_read16(hw, port, GM_GP_CTRL); | ||
1170 | if (sky2->duplex == DUPLEX_FULL || sky2->autoneg == AUTONEG_ENABLE) | ||
1171 | reg |= GM_GPCR_DUP_FULL; | ||
1172 | |||
1173 | |||
1174 | /* enable Rx/Tx */ | ||
1175 | reg |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA; | ||
1176 | gma_write16(hw, port, GM_GP_CTRL, reg); | ||
1177 | gma_read16(hw, port, GM_GP_CTRL); | ||
1178 | |||
1179 | gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK); | ||
1180 | |||
1181 | netif_carrier_on(sky2->netdev); | ||
1182 | netif_wake_queue(sky2->netdev); | ||
1183 | |||
1184 | /* Turn on link LED */ | ||
1185 | sky2_write8(hw, SK_REG(port, LNK_LED_REG), | ||
1186 | LINKLED_ON | LINKLED_BLINK_OFF | LINKLED_LINKSYNC_OFF); | ||
1187 | |||
1188 | if (netif_msg_link(sky2)) | ||
1189 | printk(KERN_INFO PFX | ||
1190 | "%s: Link is up at %d Mbps, %s duplex, flowcontrol %s\n", | ||
1191 | sky2->netdev->name, sky2->speed, | ||
1192 | sky2->duplex == DUPLEX_FULL ? "full" : "half", | ||
1193 | (sky2->tx_pause && sky2->rx_pause) ? "both" : | ||
1194 | sky2->tx_pause ? "tx" : | ||
1195 | sky2->rx_pause ? "rx" : "none"); | ||
1196 | } | ||
1197 | |||
1198 | static void sky2_link_down(struct sky2_port *sky2) | ||
1199 | { | ||
1200 | struct sky2_hw *hw = sky2->hw; | ||
1201 | unsigned port = sky2->port; | ||
1202 | u16 reg; | ||
1203 | |||
1204 | gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0); | ||
1205 | |||
1206 | reg = gma_read16(hw, port, GM_GP_CTRL); | ||
1207 | reg &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA); | ||
1208 | gma_write16(hw, port, GM_GP_CTRL, reg); | ||
1209 | gma_read16(hw, port, GM_GP_CTRL); /* PCI post */ | ||
1210 | |||
1211 | if (sky2->rx_pause && !sky2->tx_pause) { | ||
1212 | /* restore Asymmetric Pause bit */ | ||
1213 | gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, | ||
1214 | gm_phy_read(hw, port, | ||
1215 | PHY_MARV_AUNE_ADV) | ||
1216 | | PHY_M_AN_ASP); | ||
1217 | } | ||
1218 | |||
1219 | sky2_phy_reset(hw, port); | ||
1220 | |||
1221 | netif_carrier_off(sky2->netdev); | ||
1222 | netif_stop_queue(sky2->netdev); | ||
1223 | |||
1224 | /* Turn on link LED */ | ||
1225 | sky2_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF); | ||
1226 | |||
1227 | if (netif_msg_link(sky2)) | ||
1228 | printk(KERN_INFO PFX "%s: Link is down.\n", sky2->netdev->name); | ||
1229 | sky2_phy_init(hw, port); | ||
1230 | } | ||
1231 | |||
1232 | |||
1233 | /* | ||
1234 | * Interrrupt from PHY are handled in tasklet (soft irq) | ||
1235 | * because accessing phy registers requires spin wait which might | ||
1236 | * cause excess interrupt latency. | ||
1237 | */ | ||
1238 | static void sky2_phy_task(unsigned long data) | ||
1239 | { | ||
1240 | struct sky2_port *sky2 = (struct sky2_port *) data; | ||
1241 | struct sky2_hw *hw = sky2->hw; | ||
1242 | unsigned port = sky2->port; | ||
1243 | u16 istatus, phystat; | ||
1244 | |||
1245 | istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT); | ||
1246 | |||
1247 | phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT); | ||
1248 | |||
1249 | if (netif_msg_intr(sky2)) | ||
1250 | printk(KERN_INFO PFX "%s: phy interrupt status 0x%x 0x%x\n", | ||
1251 | sky2->netdev->name, istatus, phystat); | ||
1252 | |||
1253 | if (istatus & PHY_M_IS_AN_COMPL) { | ||
1254 | u16 lpa = gm_phy_read(hw, port, PHY_MARV_AUNE_LP); | ||
1255 | |||
1256 | if (lpa & PHY_M_AN_RF) { | ||
1257 | printk(KERN_ERR PFX "%s: remote fault", | ||
1258 | sky2->netdev->name); | ||
1259 | } | ||
1260 | else if (hw->chip_id != CHIP_ID_YUKON_FE | ||
1261 | && gm_phy_read(hw, port, PHY_MARV_1000T_STAT) | ||
1262 | & PHY_B_1000S_MSF) { | ||
1263 | printk(KERN_ERR PFX "%s: master/slave fault", | ||
1264 | sky2->netdev->name); | ||
1265 | } | ||
1266 | else if (!(phystat & PHY_M_PS_SPDUP_RES)) { | ||
1267 | printk(KERN_ERR PFX "%s: speed/duplex mismatch", | ||
1268 | sky2->netdev->name); | ||
1269 | } | ||
1270 | else { | ||
1271 | sky2->duplex = (phystat & PHY_M_PS_FULL_DUP) | ||
1272 | ? DUPLEX_FULL : DUPLEX_HALF; | ||
1273 | |||
1274 | sky2->speed = sky2_phy_speed(hw, phystat); | ||
1275 | |||
1276 | sky2->tx_pause = (phystat & PHY_M_PS_TX_P_EN) != 0; | ||
1277 | sky2->rx_pause = (phystat & PHY_M_PS_RX_P_EN) != 0; | ||
1278 | |||
1279 | if ((!sky2->tx_pause && !sky2->rx_pause) || | ||
1280 | (sky2->speed < SPEED_1000 && sky2->duplex == DUPLEX_HALF)) | ||
1281 | sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF); | ||
1282 | else | ||
1283 | sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON); | ||
1284 | sky2_link_up(sky2); | ||
1285 | } | ||
1286 | } else { | ||
1287 | |||
1288 | if (istatus & PHY_M_IS_LSP_CHANGE) | ||
1289 | sky2->speed = sky2_phy_speed(hw, phystat); | ||
1290 | |||
1291 | if (istatus & PHY_M_IS_DUP_CHANGE) | ||
1292 | sky2->duplex = (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF; | ||
1293 | if (istatus & PHY_M_IS_LST_CHANGE) { | ||
1294 | if (phystat & PHY_M_PS_LINK_UP) | ||
1295 | sky2_link_up(sky2); | ||
1296 | else | ||
1297 | sky2_link_down(sky2); | ||
1298 | } | ||
1299 | } | ||
1300 | |||
1301 | local_irq_disable(); | ||
1302 | hw->intr_mask |= (port == 0) ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2; | ||
1303 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
1304 | local_irq_enable(); | ||
1305 | } | ||
1306 | |||
1307 | static void sky2_tx_timeout(struct net_device *dev) | ||
1308 | { | ||
1309 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1310 | |||
1311 | if (netif_msg_timer(sky2)) | ||
1312 | printk(KERN_ERR PFX "%s: tx timeout\n", dev->name); | ||
1313 | |||
1314 | sky2_write32(sky2->hw, Q_ADDR(txqaddr[sky2->port], Q_CSR), BMU_STOP); | ||
1315 | sky2_read32(sky2->hw, Q_ADDR(txqaddr[sky2->port], Q_CSR)); | ||
1316 | |||
1317 | sky2_tx_clean(sky2); | ||
1318 | } | ||
1319 | |||
1320 | static int sky2_change_mtu(struct net_device *dev, int new_mtu) | ||
1321 | { | ||
1322 | int err = 0; | ||
1323 | |||
1324 | if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU) | ||
1325 | return -EINVAL; | ||
1326 | |||
1327 | if (netif_running(dev)) | ||
1328 | sky2_down(dev); | ||
1329 | |||
1330 | dev->mtu = new_mtu; | ||
1331 | |||
1332 | if (netif_running(dev)) | ||
1333 | err = sky2_up(dev); | ||
1334 | |||
1335 | return err; | ||
1336 | } | ||
1337 | |||
1338 | /* | ||
1339 | * Receive one packet. | ||
1340 | * For small packets or errors, just reuse existing skb. | ||
1341 | * For larger pakects, get new buffer. | ||
1342 | */ | ||
1343 | static struct sk_buff *sky2_receive(struct sky2_hw *hw, unsigned port, | ||
1344 | u16 length, u32 status) | ||
1345 | { | ||
1346 | struct net_device *dev = hw->dev[port]; | ||
1347 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1348 | struct ring_info *re = sky2->rx_ring + sky2->rx_next; | ||
1349 | struct sk_buff *skb = re->skb; | ||
1350 | dma_addr_t mapping; | ||
1351 | const unsigned int rx_buf_size = dev->mtu + ETH_HLEN + 8; | ||
1352 | |||
1353 | if (unlikely(netif_msg_rx_status(sky2))) | ||
1354 | printk(KERN_DEBUG PFX "%s: rx slot %u status 0x%x len %d\n", | ||
1355 | dev->name, sky2->rx_next, status, length); | ||
1356 | |||
1357 | sky2->rx_next = (sky2->rx_next + 1) % sky2->rx_ring_size; | ||
1358 | |||
1359 | pci_unmap_single(sky2->hw->pdev, | ||
1360 | pci_unmap_addr(re, mapaddr), | ||
1361 | pci_unmap_len(re, maplen), | ||
1362 | PCI_DMA_FROMDEVICE); | ||
1363 | prefetch(skb->data); | ||
1364 | |||
1365 | if (!(status & GMR_FS_RX_OK) | ||
1366 | || (status & GMR_FS_ANY_ERR) | ||
1367 | || (length << 16) != (status & GMR_FS_LEN) | ||
1368 | || length > rx_buf_size) | ||
1369 | goto error; | ||
1370 | |||
1371 | re->skb = sky2_rx_alloc_skb(sky2, rx_buf_size, GFP_ATOMIC); | ||
1372 | if (!re->skb) | ||
1373 | goto reuse; | ||
1374 | |||
1375 | submit: | ||
1376 | mapping = pci_map_single(sky2->hw->pdev, re->skb->data, | ||
1377 | rx_buf_size, PCI_DMA_FROMDEVICE); | ||
1378 | |||
1379 | pci_unmap_len_set(re, maplen, rx_buf_size); | ||
1380 | pci_unmap_addr_set(re, mapaddr, mapping); | ||
1381 | |||
1382 | sky2_rx_add(sky2, mapping, rx_buf_size); | ||
1383 | sky2_put_idx(sky2->hw, rxqaddr[sky2->port], | ||
1384 | sky2->rx_put, &sky2->rx_last_put, RX_LE_SIZE); | ||
1385 | |||
1386 | return skb; | ||
1387 | |||
1388 | error: | ||
1389 | if (netif_msg_rx_err(sky2)) | ||
1390 | printk(KERN_INFO PFX "%s: rx error, status 0x%x length %d\n", | ||
1391 | sky2->netdev->name, status, length); | ||
1392 | |||
1393 | if (status & (GMR_FS_LONG_ERR|GMR_FS_UN_SIZE)) | ||
1394 | sky2->net_stats.rx_length_errors++; | ||
1395 | if (status & GMR_FS_FRAGMENT) | ||
1396 | sky2->net_stats.rx_frame_errors++; | ||
1397 | if (status & GMR_FS_CRC_ERR) | ||
1398 | sky2->net_stats.rx_crc_errors++; | ||
1399 | reuse: | ||
1400 | re->skb = skb; | ||
1401 | skb = NULL; | ||
1402 | goto submit; | ||
1403 | } | ||
1404 | |||
1405 | static u16 get_tx_index(u8 port, u32 status, u16 len) | ||
1406 | { | ||
1407 | if (port == 0) | ||
1408 | return status & 0xfff; | ||
1409 | else | ||
1410 | return ((status >> 24) & 0xff) | (len & 0xf) << 8; | ||
1411 | } | ||
1412 | |||
1413 | /* | ||
1414 | * NAPI poll routine. | ||
1415 | * Both ports share the same status interrupt, therefore there is only | ||
1416 | * one poll routine. | ||
1417 | * | ||
1418 | */ | ||
1419 | static int sky2_poll(struct net_device *dev, int *budget) | ||
1420 | { | ||
1421 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1422 | struct sky2_hw *hw = sky2->hw; | ||
1423 | unsigned int to_do = min(dev->quota, *budget); | ||
1424 | unsigned int work_done = 0; | ||
1425 | unsigned char summed[2] = { CHECKSUM_NONE, CHECKSUM_NONE }; | ||
1426 | unsigned int csum[2] = { 0 }; | ||
1427 | unsigned int rx_handled[2] = { 0, 0}; | ||
1428 | u16 last; | ||
1429 | |||
1430 | sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ); | ||
1431 | last = sky2_read16(hw, STAT_PUT_IDX); | ||
1432 | |||
1433 | while (hw->st_idx != last && work_done < to_do) { | ||
1434 | struct sky2_status_le *le = hw->st_le + hw->st_idx; | ||
1435 | struct sk_buff *skb; | ||
1436 | u8 port; | ||
1437 | u32 status; | ||
1438 | u16 length; | ||
1439 | |||
1440 | rmb(); | ||
1441 | status = le32_to_cpu(le->status); | ||
1442 | length = le16_to_cpu(le->length); | ||
1443 | port = le->link; | ||
1444 | |||
1445 | BUG_ON(port >= hw->ports); | ||
1446 | |||
1447 | switch(le->opcode & ~HW_OWNER) { | ||
1448 | case OP_RXSTAT: | ||
1449 | ++rx_handled[port]; | ||
1450 | skb = sky2_receive(hw, port, length, status); | ||
1451 | if (likely(skb)) { | ||
1452 | __skb_put(skb, length); | ||
1453 | skb->protocol = eth_type_trans(skb, dev); | ||
1454 | |||
1455 | /* Add hw checksum if available */ | ||
1456 | skb->ip_summed = summed[port]; | ||
1457 | skb->csum = csum[port]; | ||
1458 | |||
1459 | /* Clear for next packet */ | ||
1460 | csum[port] = 0; | ||
1461 | summed[port] = CHECKSUM_NONE; | ||
1462 | |||
1463 | netif_receive_skb(skb); | ||
1464 | |||
1465 | dev->last_rx = jiffies; | ||
1466 | ++work_done; | ||
1467 | } | ||
1468 | break; | ||
1469 | |||
1470 | case OP_RXCHKS: | ||
1471 | /* Save computed checksum for next rx */ | ||
1472 | csum[port] = le16_to_cpu(status & 0xffff); | ||
1473 | summed[port] = CHECKSUM_HW; | ||
1474 | break; | ||
1475 | |||
1476 | case OP_TXINDEXLE: | ||
1477 | sky2_tx_complete(hw->dev[port], | ||
1478 | get_tx_index(port, status, length)); | ||
1479 | break; | ||
1480 | |||
1481 | case OP_RXTIMESTAMP: | ||
1482 | break; | ||
1483 | |||
1484 | default: | ||
1485 | if (net_ratelimit()) | ||
1486 | printk(KERN_WARNING PFX "unknown status opcode 0x%x\n", | ||
1487 | le->opcode); | ||
1488 | break; | ||
1489 | } | ||
1490 | |||
1491 | hw->st_idx = (hw->st_idx + 1) & (STATUS_RING_SIZE -1); | ||
1492 | } | ||
1493 | |||
1494 | *budget -= work_done; | ||
1495 | dev->quota -= work_done; | ||
1496 | if (work_done < to_do) { | ||
1497 | /* | ||
1498 | * Another chip workaround, need to restart TX timer if status | ||
1499 | * LE was handled. WA_DEV_43_418 | ||
1500 | */ | ||
1501 | if (is_ec_a1(hw)) { | ||
1502 | sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP); | ||
1503 | sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START); | ||
1504 | } | ||
1505 | |||
1506 | hw->intr_mask |= Y2_IS_STAT_BMU; | ||
1507 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
1508 | netif_rx_complete(dev); | ||
1509 | } | ||
1510 | |||
1511 | return work_done >= to_do; | ||
1512 | |||
1513 | } | ||
1514 | |||
1515 | static void sky2_hw_error(struct sky2_hw *hw, unsigned port, u32 status) | ||
1516 | { | ||
1517 | struct net_device *dev = hw->dev[port]; | ||
1518 | |||
1519 | printk(KERN_INFO PFX "%s: hw error interrupt status 0x%x\n", | ||
1520 | dev->name, status); | ||
1521 | |||
1522 | if (status & Y2_IS_PAR_RD1) { | ||
1523 | printk(KERN_ERR PFX "%s: ram data read parity error\n", | ||
1524 | dev->name); | ||
1525 | /* Clear IRQ */ | ||
1526 | sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_RD_PERR); | ||
1527 | } | ||
1528 | |||
1529 | if (status & Y2_IS_PAR_WR1) { | ||
1530 | printk(KERN_ERR PFX "%s: ram data write parity error\n", | ||
1531 | dev->name); | ||
1532 | |||
1533 | sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_WR_PERR); | ||
1534 | } | ||
1535 | |||
1536 | if (status & Y2_IS_PAR_MAC1) { | ||
1537 | printk(KERN_ERR PFX "%s: MAC parity error\n", dev->name); | ||
1538 | sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_PE); | ||
1539 | } | ||
1540 | |||
1541 | if (status & Y2_IS_PAR_RX1) { | ||
1542 | printk(KERN_ERR PFX "%s: RX parity error\n", dev->name); | ||
1543 | sky2_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), BMU_CLR_IRQ_PAR); | ||
1544 | } | ||
1545 | |||
1546 | if (status & Y2_IS_TCP_TXA1) { | ||
1547 | printk(KERN_ERR PFX "%s: TCP segmentation error\n", dev->name); | ||
1548 | sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_CLR_IRQ_TCP); | ||
1549 | } | ||
1550 | } | ||
1551 | |||
1552 | static void sky2_hw_intr(struct sky2_hw *hw) | ||
1553 | { | ||
1554 | u32 status = sky2_read32(hw, B0_HWE_ISRC); | ||
1555 | |||
1556 | if (status & Y2_IS_TIST_OV) { | ||
1557 | pr_debug (PFX "%s: unused timer overflow??\n", | ||
1558 | pci_name(hw->pdev)); | ||
1559 | sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ); | ||
1560 | } | ||
1561 | |||
1562 | if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) { | ||
1563 | u16 pci_err = sky2_read16(hw, PCI_C(PCI_STATUS)); | ||
1564 | printk(KERN_ERR PFX "%s: pci hw error (0x%x)\n", | ||
1565 | pci_name(hw->pdev), pci_err); | ||
1566 | |||
1567 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); | ||
1568 | sky2_write16(hw, PCI_C(PCI_STATUS), | ||
1569 | pci_err | PCI_STATUS_ERROR_BITS); | ||
1570 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); | ||
1571 | } | ||
1572 | |||
1573 | if (status & Y2_IS_PCI_EXP) { | ||
1574 | /* PCI-Express uncorrectable Error occured */ | ||
1575 | u32 pex_err = sky2_read32(hw, PCI_C(PEX_UNC_ERR_STAT)); | ||
1576 | |||
1577 | /* | ||
1578 | * On PCI-Express bus bridges are called root complexes. | ||
1579 | * PCI-Express errors are recognized by the root complex too, | ||
1580 | * which requests the system to handle the problem. After error | ||
1581 | * occurence it may be that no access to the adapter may be performed | ||
1582 | * any longer. | ||
1583 | */ | ||
1584 | printk(KERN_ERR PFX "%s: pci express error (0x%x)\n", | ||
1585 | pci_name(hw->pdev), pex_err); | ||
1586 | |||
1587 | /* clear the interrupt */ | ||
1588 | sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); | ||
1589 | sky2_write32(hw, PCI_C(PEX_UNC_ERR_STAT), 0xffffffffUL); | ||
1590 | sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); | ||
1591 | |||
1592 | if (pex_err & PEX_FATAL_ERRORS) { | ||
1593 | u32 hwmsk = sky2_read32(hw, B0_HWE_IMSK); | ||
1594 | hwmsk &= ~Y2_IS_PCI_EXP; | ||
1595 | sky2_write32(hw, B0_HWE_IMSK, hwmsk); | ||
1596 | } | ||
1597 | } | ||
1598 | |||
1599 | if (status & Y2_HWE_L1_MASK) | ||
1600 | sky2_hw_error(hw, 0, status); | ||
1601 | status >>= 8; | ||
1602 | if (status & Y2_HWE_L1_MASK) | ||
1603 | sky2_hw_error(hw, 1, status); | ||
1604 | } | ||
1605 | |||
1606 | static void sky2_mac_intr(struct sky2_hw *hw, unsigned port) | ||
1607 | { | ||
1608 | struct net_device *dev = hw->dev[port]; | ||
1609 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1610 | u8 status = sky2_read8(hw, SK_REG(port, GMAC_IRQ_SRC)); | ||
1611 | |||
1612 | if (netif_msg_intr(sky2)) | ||
1613 | printk(KERN_INFO PFX "%s: mac interrupt status 0x%x\n", | ||
1614 | dev->name, status); | ||
1615 | |||
1616 | if (status & GM_IS_RX_FF_OR) { | ||
1617 | ++sky2->net_stats.rx_fifo_errors; | ||
1618 | sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_CLI_RX_FO); | ||
1619 | } | ||
1620 | |||
1621 | if (status & GM_IS_TX_FF_UR) { | ||
1622 | ++sky2->net_stats.tx_fifo_errors; | ||
1623 | sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_FU); | ||
1624 | } | ||
1625 | |||
1626 | } | ||
1627 | |||
1628 | static void sky2_phy_intr(struct sky2_hw *hw, unsigned port) | ||
1629 | { | ||
1630 | struct net_device *dev = hw->dev[port]; | ||
1631 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1632 | |||
1633 | hw->intr_mask &= ~(port == 0 ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2); | ||
1634 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
1635 | tasklet_schedule(&sky2->phy_task); | ||
1636 | } | ||
1637 | |||
1638 | static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs) | ||
1639 | { | ||
1640 | struct sky2_hw *hw = dev_id; | ||
1641 | u32 status; | ||
1642 | |||
1643 | status = sky2_read32(hw, B0_Y2_SP_ISRC2); | ||
1644 | if (status == 0 || status == ~0) /* hotplug or shared irq */ | ||
1645 | return IRQ_NONE; | ||
1646 | |||
1647 | if (status & Y2_IS_HW_ERR) | ||
1648 | sky2_hw_intr(hw); | ||
1649 | |||
1650 | if ((status & Y2_IS_STAT_BMU) && netif_rx_schedule_prep(hw->dev[0])) { | ||
1651 | hw->intr_mask &= ~Y2_IS_STAT_BMU; | ||
1652 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
1653 | __netif_rx_schedule(hw->dev[0]); | ||
1654 | } | ||
1655 | |||
1656 | if (status & Y2_IS_IRQ_PHY1) | ||
1657 | sky2_phy_intr(hw, 0); | ||
1658 | |||
1659 | if (status & Y2_IS_IRQ_PHY2) | ||
1660 | sky2_phy_intr(hw, 1); | ||
1661 | |||
1662 | if (status & Y2_IS_IRQ_MAC1) | ||
1663 | sky2_mac_intr(hw, 0); | ||
1664 | |||
1665 | if (status & Y2_IS_IRQ_MAC2) | ||
1666 | sky2_mac_intr(hw, 1); | ||
1667 | |||
1668 | |||
1669 | sky2_write32(hw, B0_Y2_SP_ICR, 2); | ||
1670 | return IRQ_HANDLED; | ||
1671 | } | ||
1672 | |||
1673 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
1674 | static void sky2_netpoll(struct net_device *dev) | ||
1675 | { | ||
1676 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1677 | |||
1678 | disable_irq(dev->irq); | ||
1679 | sky2_intr(dev->irq, sky2->hw, NULL); | ||
1680 | enable_irq(dev->irq); | ||
1681 | } | ||
1682 | #endif | ||
1683 | |||
1684 | /* Chip internal frequency for clock calculations */ | ||
1685 | static inline u32 sky2_khz(const struct sky2_hw *hw) | ||
1686 | { | ||
1687 | switch(hw->chip_id) { | ||
1688 | case CHIP_ID_YUKON_EC: | ||
1689 | return 125000; /* 125 Mhz */ | ||
1690 | case CHIP_ID_YUKON_FE: | ||
1691 | return 100000; /* 100 Mhz */ | ||
1692 | default: /* YUKON_XL */ | ||
1693 | return 156000; /* 156 Mhz */ | ||
1694 | } | ||
1695 | } | ||
1696 | |||
1697 | static inline u32 sky2_ms2clk(const struct sky2_hw *hw, u32 ms) | ||
1698 | { | ||
1699 | return sky2_khz(hw) * ms; | ||
1700 | } | ||
1701 | |||
1702 | static inline u32 sky2_us2clk(const struct sky2_hw *hw, u32 us) | ||
1703 | { | ||
1704 | return (sky2_khz(hw) * 75) / 1000; | ||
1705 | } | ||
1706 | |||
1707 | static int sky2_reset(struct sky2_hw *hw) | ||
1708 | { | ||
1709 | u32 ctst, power; | ||
1710 | u16 status; | ||
1711 | u8 t8, pmd_type; | ||
1712 | int i; | ||
1713 | |||
1714 | ctst = sky2_read32(hw, B0_CTST); | ||
1715 | |||
1716 | sky2_write8(hw, B0_CTST, CS_RST_CLR); | ||
1717 | hw->chip_id = sky2_read8(hw, B2_CHIP_ID); | ||
1718 | if (hw->chip_id < CHIP_ID_YUKON_XL || hw->chip_id > CHIP_ID_YUKON_FE) { | ||
1719 | printk(KERN_ERR PFX "%s: unsupported chip type 0x%x\n", | ||
1720 | pci_name(hw->pdev), hw->chip_id); | ||
1721 | return -EOPNOTSUPP; | ||
1722 | } | ||
1723 | |||
1724 | /* disable ASF */ | ||
1725 | if (hw->chip_id <= CHIP_ID_YUKON_EC) { | ||
1726 | sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET); | ||
1727 | sky2_write16(hw, B0_CTST, Y2_ASF_DISABLE); | ||
1728 | } | ||
1729 | |||
1730 | /* do a SW reset */ | ||
1731 | sky2_write8(hw, B0_CTST, CS_RST_SET); | ||
1732 | sky2_write8(hw, B0_CTST, CS_RST_CLR); | ||
1733 | |||
1734 | /* clear PCI errors, if any */ | ||
1735 | status = sky2_read16(hw, PCI_C(PCI_STATUS)); | ||
1736 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); | ||
1737 | sky2_write16(hw, PCI_C(PCI_STATUS), | ||
1738 | status | PCI_STATUS_ERROR_BITS); | ||
1739 | |||
1740 | sky2_write8(hw, B0_CTST, CS_MRST_CLR); | ||
1741 | |||
1742 | /* clear any PEX errors */ | ||
1743 | if (is_pciex(hw)) { | ||
1744 | sky2_write32(hw, PCI_C(PEX_UNC_ERR_STAT), 0xffffffffUL); | ||
1745 | sky2_read16(hw, PCI_C(PEX_LNK_STAT)); | ||
1746 | } | ||
1747 | |||
1748 | pmd_type = sky2_read8(hw, B2_PMD_TYP); | ||
1749 | hw->copper = !(pmd_type == 'L' || pmd_type == 'S'); | ||
1750 | |||
1751 | hw->ports = 1; | ||
1752 | t8 = sky2_read8(hw, B2_Y2_HW_RES); | ||
1753 | if ((t8 & CFG_DUAL_MAC_MSK) == CFG_DUAL_MAC_MSK) { | ||
1754 | if (!(sky2_read8(hw, B2_Y2_CLK_GATE) & Y2_STATUS_LNK2_INAC)) | ||
1755 | ++hw->ports; | ||
1756 | } | ||
1757 | hw->chip_rev = (sky2_read8(hw, B2_MAC_CFG) & CFG_CHIP_R_MSK) >> 4; | ||
1758 | |||
1759 | /* switch power to VCC (WA for VAUX problem) */ | ||
1760 | sky2_write8(hw, B0_POWER_CTRL, | ||
1761 | PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON); | ||
1762 | |||
1763 | /* disable Core Clock Division, */ | ||
1764 | sky2_write32(hw, B2_Y2_CLK_CTRL, Y2_CLK_DIV_DIS); | ||
1765 | |||
1766 | if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) | ||
1767 | /* enable bits are inverted */ | ||
1768 | sky2_write8(hw, B2_Y2_CLK_GATE, | ||
1769 | Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS | | ||
1770 | Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS | | ||
1771 | Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS); | ||
1772 | else | ||
1773 | sky2_write8(hw, B2_Y2_CLK_GATE, 0); | ||
1774 | |||
1775 | /* Turn off phy power saving */ | ||
1776 | power = sky2_read32(hw, PCI_C(PCI_DEV_REG1)); | ||
1777 | power &= ~(PCI_Y2_PHY1_POWD|PCI_Y2_PHY2_POWD); | ||
1778 | |||
1779 | /* back asswards .. */ | ||
1780 | if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) { | ||
1781 | power |= PCI_Y2_PHY1_COMA; | ||
1782 | if (hw->ports > 1) | ||
1783 | power |= PCI_Y2_PHY2_COMA; | ||
1784 | } | ||
1785 | sky2_write32(hw, PCI_C(PCI_DEV_REG1), power); | ||
1786 | |||
1787 | for (i = 0; i < hw->ports; i++) { | ||
1788 | sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET); | ||
1789 | sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_CLR); | ||
1790 | } | ||
1791 | |||
1792 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); | ||
1793 | |||
1794 | sky2_write32(hw, B2_I2C_IRQ, 1); /* Clear I2C IRQ noise */ | ||
1795 | |||
1796 | /* turn off hardware timer (unused) */ | ||
1797 | sky2_write8(hw, B2_TI_CTRL, TIM_STOP); | ||
1798 | sky2_write8(hw, B2_TI_CTRL, TIM_CLR_IRQ); | ||
1799 | |||
1800 | sky2_write8(hw, B0_Y2LED, LED_STAT_ON); | ||
1801 | |||
1802 | /* Turn on descriptor polling -- is this necessary? */ | ||
1803 | sky2_write32(hw, B28_DPT_INI, sky2_us2clk(hw, 75)); | ||
1804 | sky2_write8(hw, B28_DPT_CTRL, DPT_START); | ||
1805 | |||
1806 | /* Turn off receive timestamp */ | ||
1807 | sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_STOP); | ||
1808 | |||
1809 | /* enable the Tx Arbiters */ | ||
1810 | for (i = 0; i < hw->ports; i++) | ||
1811 | sky2_write8(hw, SK_REG(i, TXA_CTRL), TXA_ENA_ARB); | ||
1812 | |||
1813 | /* Initialize ram interface */ | ||
1814 | for (i = 0; i < hw->ports; i++) { | ||
1815 | sky2_write16(hw, RAM_BUFFER(i, B3_RI_CTRL), RI_RST_CLR); | ||
1816 | |||
1817 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R1), SK_RI_TO_53); | ||
1818 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA1), SK_RI_TO_53); | ||
1819 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS1), SK_RI_TO_53); | ||
1820 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R1), SK_RI_TO_53); | ||
1821 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA1), SK_RI_TO_53); | ||
1822 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS1), SK_RI_TO_53); | ||
1823 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R2), SK_RI_TO_53); | ||
1824 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA2), SK_RI_TO_53); | ||
1825 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS2), SK_RI_TO_53); | ||
1826 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R2), SK_RI_TO_53); | ||
1827 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA2), SK_RI_TO_53); | ||
1828 | sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS2), SK_RI_TO_53); | ||
1829 | } | ||
1830 | |||
1831 | /* Optimize PCI Express access */ | ||
1832 | if (is_pciex(hw)) { | ||
1833 | u16 ctrl = sky2_read32(hw, PCI_C(PEX_DEV_CTRL)); | ||
1834 | ctrl &= ~PEX_DC_MAX_RRS_MSK; | ||
1835 | ctrl |= PEX_DC_MAX_RD_RQ_SIZE(4); | ||
1836 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); | ||
1837 | sky2_write16(hw, PCI_C(PEX_DEV_CTRL), ctrl); | ||
1838 | sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); | ||
1839 | } | ||
1840 | |||
1841 | sky2_write32(hw, B0_HWE_IMSK, Y2_HWE_ALL_MASK); | ||
1842 | |||
1843 | hw->intr_mask = Y2_IS_BASE; | ||
1844 | sky2_write32(hw, B0_IMSK, hw->intr_mask); | ||
1845 | |||
1846 | /* disable all GMAC IRQ's */ | ||
1847 | sky2_write8(hw, GMAC_IRQ_MSK, 0); | ||
1848 | |||
1849 | spin_lock_bh(&hw->phy_lock); | ||
1850 | for (i = 0; i < hw->ports; i++) | ||
1851 | sky2_phy_reset(hw, i); | ||
1852 | spin_unlock_bh(&hw->phy_lock); | ||
1853 | |||
1854 | /* Setup ring for status responses */ | ||
1855 | hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES, | ||
1856 | &hw->st_dma); | ||
1857 | if (!hw->st_le) | ||
1858 | return -ENOMEM; | ||
1859 | |||
1860 | memset(hw->st_le, 0, STATUS_LE_BYTES); | ||
1861 | hw->st_idx = 0; | ||
1862 | |||
1863 | sky2_write32(hw, STAT_CTRL, SC_STAT_RST_SET); | ||
1864 | sky2_write32(hw, STAT_CTRL, SC_STAT_RST_CLR); | ||
1865 | |||
1866 | sky2_write32(hw, STAT_LIST_ADDR_LO, hw->st_dma); | ||
1867 | sky2_write32(hw, STAT_LIST_ADDR_HI, (u64)hw->st_dma >> 32); | ||
1868 | |||
1869 | /* Set the list last index */ | ||
1870 | sky2_write16(hw, STAT_LAST_IDX, STATUS_RING_SIZE-1); | ||
1871 | |||
1872 | if (is_ec_a1(hw)) { | ||
1873 | /* WA for dev. #4.3 */ | ||
1874 | sky2_write16(hw, STAT_TX_IDX_TH, ST_TXTH_IDX_MASK); | ||
1875 | |||
1876 | /* set Status-FIFO watermark */ | ||
1877 | sky2_write8(hw, STAT_FIFO_WM, 0x21); /* WA for dev. #4.18 */ | ||
1878 | |||
1879 | /* set Status-FIFO ISR watermark */ | ||
1880 | sky2_write8(hw, STAT_FIFO_ISR_WM, 0x07);/* WA for dev. #4.18 */ | ||
1881 | |||
1882 | /* WA for dev. #4.3 and #4.18 */ | ||
1883 | /* set Status-FIFO Tx timer init value */ | ||
1884 | sky2_write32(hw, STAT_TX_TIMER_INI, sky2_ms2clk(hw, 10)); | ||
1885 | } else { | ||
1886 | /* | ||
1887 | * Theses settings should avoid the | ||
1888 | * temporary hanging of the status BMU. | ||
1889 | * May be not all required... still under investigation... | ||
1890 | */ | ||
1891 | sky2_write16(hw, STAT_TX_IDX_TH, 0x000a); | ||
1892 | |||
1893 | /* set Status-FIFO watermark */ | ||
1894 | sky2_write8(hw, STAT_FIFO_WM, 0x10); | ||
1895 | |||
1896 | /* set Status-FIFO ISR watermark */ | ||
1897 | if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0) | ||
1898 | sky2_write8(hw, STAT_FIFO_ISR_WM, 0x10); | ||
1899 | |||
1900 | else /* WA 4109 */ | ||
1901 | sky2_write8(hw, STAT_FIFO_ISR_WM, 0x04); | ||
1902 | |||
1903 | sky2_write32(hw, STAT_ISR_TIMER_INI, 0x0190); | ||
1904 | } | ||
1905 | |||
1906 | /* enable the prefetch unit */ | ||
1907 | /* operational bit not functional for Yukon-EC, but fixed in Yukon-2? */ | ||
1908 | sky2_write32(hw, STAT_CTRL, SC_STAT_OP_ON); | ||
1909 | |||
1910 | sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START); | ||
1911 | sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START); | ||
1912 | sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START); | ||
1913 | |||
1914 | return 0; | ||
1915 | } | ||
1916 | |||
1917 | static inline u32 sky2_supported_modes(const struct sky2_hw *hw) | ||
1918 | { | ||
1919 | u32 modes; | ||
1920 | if (hw->copper) { | ||
1921 | modes = SUPPORTED_10baseT_Half | ||
1922 | | SUPPORTED_10baseT_Full | ||
1923 | | SUPPORTED_100baseT_Half | ||
1924 | | SUPPORTED_100baseT_Full | ||
1925 | | SUPPORTED_Autoneg| SUPPORTED_TP; | ||
1926 | |||
1927 | if (hw->chip_id != CHIP_ID_YUKON_FE) | ||
1928 | modes |= SUPPORTED_1000baseT_Half | ||
1929 | | SUPPORTED_1000baseT_Full; | ||
1930 | } else | ||
1931 | modes = SUPPORTED_1000baseT_Full | SUPPORTED_FIBRE | ||
1932 | | SUPPORTED_Autoneg; | ||
1933 | return modes; | ||
1934 | } | ||
1935 | |||
1936 | static int sky2_get_settings(struct net_device *dev, | ||
1937 | struct ethtool_cmd *ecmd) | ||
1938 | { | ||
1939 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1940 | struct sky2_hw *hw = sky2->hw; | ||
1941 | |||
1942 | ecmd->transceiver = XCVR_INTERNAL; | ||
1943 | ecmd->supported = sky2_supported_modes(hw); | ||
1944 | ecmd->phy_address = PHY_ADDR_MARV; | ||
1945 | if (hw->copper) { | ||
1946 | ecmd->supported = SUPPORTED_10baseT_Half | ||
1947 | |||
1948 | | SUPPORTED_10baseT_Full | ||
1949 | | SUPPORTED_100baseT_Half | ||
1950 | | SUPPORTED_100baseT_Full | ||
1951 | | SUPPORTED_1000baseT_Half | ||
1952 | | SUPPORTED_1000baseT_Full | ||
1953 | | SUPPORTED_Autoneg| SUPPORTED_TP; | ||
1954 | ecmd->port = PORT_TP; | ||
1955 | } else | ||
1956 | ecmd->port = PORT_FIBRE; | ||
1957 | |||
1958 | ecmd->advertising = sky2->advertising; | ||
1959 | ecmd->autoneg = sky2->autoneg; | ||
1960 | ecmd->speed = sky2->speed; | ||
1961 | ecmd->duplex = sky2->duplex; | ||
1962 | return 0; | ||
1963 | } | ||
1964 | |||
1965 | static int sky2_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) | ||
1966 | { | ||
1967 | struct sky2_port *sky2 = netdev_priv(dev); | ||
1968 | const struct sky2_hw *hw = sky2->hw; | ||
1969 | u32 supported = sky2_supported_modes(hw); | ||
1970 | |||
1971 | if (ecmd->autoneg == AUTONEG_ENABLE) { | ||
1972 | ecmd->advertising = supported; | ||
1973 | sky2->duplex = -1; | ||
1974 | sky2->speed = -1; | ||
1975 | } else { | ||
1976 | u32 setting; | ||
1977 | |||
1978 | switch(ecmd->speed) { | ||
1979 | case SPEED_1000: | ||
1980 | if (ecmd->duplex == DUPLEX_FULL) | ||
1981 | setting = SUPPORTED_1000baseT_Full; | ||
1982 | else if (ecmd->duplex == DUPLEX_HALF) | ||
1983 | setting = SUPPORTED_1000baseT_Half; | ||
1984 | else | ||
1985 | return -EINVAL; | ||
1986 | break; | ||
1987 | case SPEED_100: | ||
1988 | if (ecmd->duplex == DUPLEX_FULL) | ||
1989 | setting = SUPPORTED_100baseT_Full; | ||
1990 | else if (ecmd->duplex == DUPLEX_HALF) | ||
1991 | setting = SUPPORTED_100baseT_Half; | ||
1992 | else | ||
1993 | return -EINVAL; | ||
1994 | break; | ||
1995 | |||
1996 | case SPEED_10: | ||
1997 | if (ecmd->duplex == DUPLEX_FULL) | ||
1998 | setting = SUPPORTED_10baseT_Full; | ||
1999 | else if (ecmd->duplex == DUPLEX_HALF) | ||
2000 | setting = SUPPORTED_10baseT_Half; | ||
2001 | else | ||
2002 | return -EINVAL; | ||
2003 | break; | ||
2004 | default: | ||
2005 | return -EINVAL; | ||
2006 | } | ||
2007 | |||
2008 | if ((setting & supported) == 0) | ||
2009 | return -EINVAL; | ||
2010 | |||
2011 | sky2->speed = ecmd->speed; | ||
2012 | sky2->duplex = ecmd->duplex; | ||
2013 | } | ||
2014 | |||
2015 | sky2->autoneg = ecmd->autoneg; | ||
2016 | sky2->advertising = ecmd->advertising; | ||
2017 | |||
2018 | if (netif_running(dev)) { | ||
2019 | sky2_down(dev); | ||
2020 | sky2_up(dev); | ||
2021 | } | ||
2022 | |||
2023 | return 0; | ||
2024 | } | ||
2025 | |||
2026 | static void sky2_get_drvinfo(struct net_device *dev, | ||
2027 | struct ethtool_drvinfo *info) | ||
2028 | { | ||
2029 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2030 | |||
2031 | strcpy(info->driver, DRV_NAME); | ||
2032 | strcpy(info->version, DRV_VERSION); | ||
2033 | strcpy(info->fw_version, "N/A"); | ||
2034 | strcpy(info->bus_info, pci_name(sky2->hw->pdev)); | ||
2035 | } | ||
2036 | |||
2037 | static const struct sky2_stat { | ||
2038 | char name[ETH_GSTRING_LEN]; | ||
2039 | u16 offset; | ||
2040 | } sky2_stats[] = { | ||
2041 | { "tx_bytes", GM_TXO_OK_HI }, | ||
2042 | { "rx_bytes", GM_RXO_OK_HI }, | ||
2043 | { "tx_broadcast", GM_TXF_BC_OK }, | ||
2044 | { "rx_broadcast", GM_RXF_BC_OK }, | ||
2045 | { "tx_multicast", GM_TXF_MC_OK }, | ||
2046 | { "rx_multicast", GM_RXF_MC_OK }, | ||
2047 | { "tx_unicast", GM_TXF_UC_OK }, | ||
2048 | { "rx_unicast", GM_RXF_UC_OK }, | ||
2049 | { "tx_mac_pause", GM_TXF_MPAUSE }, | ||
2050 | { "rx_mac_pause", GM_RXF_MPAUSE }, | ||
2051 | { "collisions", GM_TXF_SNG_COL }, | ||
2052 | { "late_collision",GM_TXF_LAT_COL }, | ||
2053 | { "aborted", GM_TXF_ABO_COL }, | ||
2054 | { "multi_collisions", GM_TXF_MUL_COL }, | ||
2055 | { "fifo_underrun", GM_TXE_FIFO_UR }, | ||
2056 | { "fifo_overflow", GM_RXE_FIFO_OV }, | ||
2057 | { "rx_toolong", GM_RXF_LNG_ERR }, | ||
2058 | { "rx_jabber", GM_RXF_JAB_PKT }, | ||
2059 | { "rx_runt", GM_RXE_FRAG }, | ||
2060 | { "rx_too_long", GM_RXF_LNG_ERR }, | ||
2061 | { "rx_fcs_error", GM_RXF_FCS_ERR }, | ||
2062 | }; | ||
2063 | |||
2064 | |||
2065 | static u32 sky2_get_rx_csum(struct net_device *dev) | ||
2066 | { | ||
2067 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2068 | |||
2069 | return sky2->rx_csum; | ||
2070 | } | ||
2071 | |||
2072 | static int sky2_set_rx_csum(struct net_device *dev, u32 data) | ||
2073 | { | ||
2074 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2075 | |||
2076 | sky2->rx_csum = data; | ||
2077 | sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR), | ||
2078 | data ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM); | ||
2079 | |||
2080 | return 0; | ||
2081 | } | ||
2082 | |||
2083 | static u32 sky2_get_msglevel(struct net_device *netdev) | ||
2084 | { | ||
2085 | struct sky2_port *sky2 = netdev_priv(netdev); | ||
2086 | return sky2->msg_enable; | ||
2087 | } | ||
2088 | |||
2089 | static void sky2_phy_stats(struct sky2_port *sky2, u64 *data) | ||
2090 | { | ||
2091 | struct sky2_hw *hw = sky2->hw; | ||
2092 | unsigned port = sky2->port; | ||
2093 | int i; | ||
2094 | |||
2095 | data[0] = (u64) gma_read32(hw, port, GM_TXO_OK_HI) << 32 | ||
2096 | | (u64) gma_read32(hw, port, GM_TXO_OK_LO); | ||
2097 | data[1] = (u64) gma_read32(hw, port, GM_RXO_OK_HI) << 32 | ||
2098 | | (u64) gma_read32(hw, port, GM_RXO_OK_LO); | ||
2099 | |||
2100 | for (i = 2; i < ARRAY_SIZE(sky2_stats); i++) | ||
2101 | data[i] = (u64) gma_read32(hw, port, sky2_stats[i].offset); | ||
2102 | } | ||
2103 | |||
2104 | |||
2105 | static void sky2_set_msglevel(struct net_device *netdev, u32 value) | ||
2106 | { | ||
2107 | struct sky2_port *sky2 = netdev_priv(netdev); | ||
2108 | sky2->msg_enable = value; | ||
2109 | } | ||
2110 | |||
2111 | static int sky2_get_stats_count(struct net_device *dev) | ||
2112 | { | ||
2113 | return ARRAY_SIZE(sky2_stats); | ||
2114 | } | ||
2115 | |||
2116 | static void sky2_get_ethtool_stats(struct net_device *dev, | ||
2117 | struct ethtool_stats *stats, u64 *data) | ||
2118 | { | ||
2119 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2120 | |||
2121 | sky2_phy_stats(sky2, data); | ||
2122 | } | ||
2123 | |||
2124 | static void sky2_get_strings(struct net_device *dev, u32 stringset, u8 *data) | ||
2125 | { | ||
2126 | int i; | ||
2127 | |||
2128 | switch (stringset) { | ||
2129 | case ETH_SS_STATS: | ||
2130 | for (i = 0; i < ARRAY_SIZE(sky2_stats); i++) | ||
2131 | memcpy(data + i * ETH_GSTRING_LEN, | ||
2132 | sky2_stats[i].name, ETH_GSTRING_LEN); | ||
2133 | break; | ||
2134 | } | ||
2135 | } | ||
2136 | |||
2137 | /* Use hardware MIB variables for critical path statistics and | ||
2138 | * transmit feedback not reported at interrupt. | ||
2139 | * Other errors are accounted for in interrupt handler. | ||
2140 | */ | ||
2141 | static struct net_device_stats *sky2_get_stats(struct net_device *dev) | ||
2142 | { | ||
2143 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2144 | u64 data[ARRAY_SIZE(sky2_stats)]; | ||
2145 | |||
2146 | sky2_phy_stats(sky2, data); | ||
2147 | |||
2148 | sky2->net_stats.tx_bytes = data[0]; | ||
2149 | sky2->net_stats.rx_bytes = data[1]; | ||
2150 | sky2->net_stats.tx_packets = data[2] + data[4] + data[6]; | ||
2151 | sky2->net_stats.rx_packets = data[3] + data[5] + data[7]; | ||
2152 | sky2->net_stats.multicast = data[5] + data[7]; | ||
2153 | sky2->net_stats.collisions = data[10]; | ||
2154 | sky2->net_stats.tx_aborted_errors = data[12]; | ||
2155 | |||
2156 | return &sky2->net_stats; | ||
2157 | } | ||
2158 | |||
2159 | static int sky2_set_mac_address(struct net_device *dev, void *p) | ||
2160 | { | ||
2161 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2162 | struct sockaddr *addr = p; | ||
2163 | int err = 0; | ||
2164 | |||
2165 | if (!is_valid_ether_addr(addr->sa_data)) | ||
2166 | return -EADDRNOTAVAIL; | ||
2167 | |||
2168 | sky2_down(dev); | ||
2169 | memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); | ||
2170 | memcpy_toio(sky2->hw->regs + B2_MAC_1 + sky2->port*8, | ||
2171 | dev->dev_addr, ETH_ALEN); | ||
2172 | memcpy_toio(sky2->hw->regs + B2_MAC_2 + sky2->port*8, | ||
2173 | dev->dev_addr, ETH_ALEN); | ||
2174 | if (dev->flags & IFF_UP) | ||
2175 | err = sky2_up(dev); | ||
2176 | return err; | ||
2177 | } | ||
2178 | |||
2179 | static void sky2_set_multicast(struct net_device *dev) | ||
2180 | { | ||
2181 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2182 | struct sky2_hw *hw = sky2->hw; | ||
2183 | unsigned port = sky2->port; | ||
2184 | struct dev_mc_list *list = dev->mc_list; | ||
2185 | u16 reg; | ||
2186 | u8 filter[8]; | ||
2187 | |||
2188 | memset(filter, 0, sizeof(filter)); | ||
2189 | |||
2190 | reg = gma_read16(hw, port, GM_RX_CTRL); | ||
2191 | reg |= GM_RXCR_UCF_ENA; | ||
2192 | |||
2193 | if (dev->flags & IFF_PROMISC) /* promiscious */ | ||
2194 | reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA); | ||
2195 | else if (dev->flags & IFF_ALLMULTI) /* all multicast */ | ||
2196 | memset(filter, 0xff, sizeof(filter)); | ||
2197 | else if (dev->mc_count == 0) /* no multicast */ | ||
2198 | reg &= ~GM_RXCR_MCF_ENA; | ||
2199 | else { | ||
2200 | int i; | ||
2201 | reg |= GM_RXCR_MCF_ENA; | ||
2202 | |||
2203 | for (i = 0; list && i < dev->mc_count; i++, list = list->next) { | ||
2204 | u32 bit = ether_crc(ETH_ALEN, list->dmi_addr) & 0x3f; | ||
2205 | filter[bit/8] |= 1 << (bit%8); | ||
2206 | } | ||
2207 | } | ||
2208 | |||
2209 | |||
2210 | gma_write16(hw, port, GM_MC_ADDR_H1, | ||
2211 | (u16)filter[0] | ((u16)filter[1] << 8)); | ||
2212 | gma_write16(hw, port, GM_MC_ADDR_H2, | ||
2213 | (u16)filter[2] | ((u16)filter[3] << 8)); | ||
2214 | gma_write16(hw, port, GM_MC_ADDR_H3, | ||
2215 | (u16)filter[4] | ((u16)filter[5] << 8)); | ||
2216 | gma_write16(hw, port, GM_MC_ADDR_H4, | ||
2217 | (u16)filter[6] | ((u16)filter[7] << 8)); | ||
2218 | |||
2219 | gma_write16(hw, port, GM_RX_CTRL, reg); | ||
2220 | } | ||
2221 | |||
2222 | /* Can have one global because blinking is controlled by | ||
2223 | * ethtool and that is always under RTNL mutex | ||
2224 | */ | ||
2225 | static inline void sky2_led(struct sky2_hw *hw, unsigned port, int on) | ||
2226 | { | ||
2227 | spin_lock_bh(&hw->phy_lock); | ||
2228 | gm_phy_write(hw, port, PHY_MARV_LED_CTRL, 0); | ||
2229 | if (on) | ||
2230 | gm_phy_write(hw, port, PHY_MARV_LED_OVER, | ||
2231 | PHY_M_LED_MO_DUP(MO_LED_ON) | | ||
2232 | PHY_M_LED_MO_10(MO_LED_ON) | | ||
2233 | PHY_M_LED_MO_100(MO_LED_ON) | | ||
2234 | PHY_M_LED_MO_1000(MO_LED_ON) | | ||
2235 | PHY_M_LED_MO_RX(MO_LED_ON)); | ||
2236 | else | ||
2237 | gm_phy_write(hw, port, PHY_MARV_LED_OVER, | ||
2238 | |||
2239 | PHY_M_LED_MO_DUP(MO_LED_OFF) | | ||
2240 | PHY_M_LED_MO_10(MO_LED_OFF) | | ||
2241 | PHY_M_LED_MO_100(MO_LED_OFF) | | ||
2242 | PHY_M_LED_MO_1000(MO_LED_OFF) | | ||
2243 | PHY_M_LED_MO_RX(MO_LED_OFF)); | ||
2244 | |||
2245 | spin_unlock_bh(&hw->phy_lock); | ||
2246 | } | ||
2247 | |||
2248 | /* blink LED's for finding board */ | ||
2249 | static int sky2_phys_id(struct net_device *dev, u32 data) | ||
2250 | { | ||
2251 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2252 | struct sky2_hw *hw = sky2->hw; | ||
2253 | unsigned port = sky2->port; | ||
2254 | u16 ledctrl, ledover; | ||
2255 | long ms; | ||
2256 | int onoff = 1; | ||
2257 | |||
2258 | if (!data || data > (u32)(MAX_SCHEDULE_TIMEOUT / HZ)) | ||
2259 | ms = jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT); | ||
2260 | else | ||
2261 | ms = data * 1000; | ||
2262 | |||
2263 | /* save initial values */ | ||
2264 | spin_lock_bh(&hw->phy_lock); | ||
2265 | ledctrl = gm_phy_read(hw, port, PHY_MARV_LED_CTRL); | ||
2266 | ledover = gm_phy_read(hw, port, PHY_MARV_LED_OVER); | ||
2267 | spin_unlock_bh(&hw->phy_lock); | ||
2268 | |||
2269 | while (ms > 0) { | ||
2270 | sky2_led(hw, port, onoff); | ||
2271 | onoff = !onoff; | ||
2272 | |||
2273 | if (msleep_interruptible(250)) | ||
2274 | break; /* interrupted */ | ||
2275 | ms -= 250; | ||
2276 | } | ||
2277 | |||
2278 | /* resume regularly scheduled programming */ | ||
2279 | spin_lock_bh(&hw->phy_lock); | ||
2280 | gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl); | ||
2281 | gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover); | ||
2282 | spin_unlock_bh(&hw->phy_lock); | ||
2283 | |||
2284 | return 0; | ||
2285 | } | ||
2286 | |||
2287 | static void sky2_get_pauseparam(struct net_device *dev, | ||
2288 | struct ethtool_pauseparam *ecmd) | ||
2289 | { | ||
2290 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2291 | |||
2292 | ecmd->tx_pause = sky2->tx_pause; | ||
2293 | ecmd->rx_pause = sky2->rx_pause; | ||
2294 | ecmd->autoneg = sky2->autoneg; | ||
2295 | } | ||
2296 | |||
2297 | static int sky2_set_pauseparam(struct net_device *dev, | ||
2298 | struct ethtool_pauseparam *ecmd) | ||
2299 | { | ||
2300 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2301 | int err = 0; | ||
2302 | |||
2303 | sky2->autoneg = ecmd->autoneg; | ||
2304 | sky2->tx_pause = ecmd->tx_pause != 0; | ||
2305 | sky2->rx_pause = ecmd->rx_pause != 0; | ||
2306 | |||
2307 | if (netif_running(dev)) { | ||
2308 | sky2_down(dev); | ||
2309 | err = sky2_up(dev); | ||
2310 | } | ||
2311 | |||
2312 | return err; | ||
2313 | } | ||
2314 | |||
2315 | #ifdef CONFIG_PM | ||
2316 | static void sky2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) | ||
2317 | { | ||
2318 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2319 | |||
2320 | wol->supported = WAKE_MAGIC; | ||
2321 | wol->wolopts = sky2->wol ? WAKE_MAGIC : 0; | ||
2322 | } | ||
2323 | |||
2324 | static int sky2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) | ||
2325 | { | ||
2326 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2327 | struct sky2_hw *hw = sky2->hw; | ||
2328 | |||
2329 | if (wol->wolopts != WAKE_MAGIC && wol->wolopts != 0) | ||
2330 | return -EOPNOTSUPP; | ||
2331 | |||
2332 | sky2->wol = wol->wolopts == WAKE_MAGIC; | ||
2333 | |||
2334 | if (sky2->wol) { | ||
2335 | memcpy_toio(hw->regs + WOL_MAC_ADDR, dev->dev_addr, ETH_ALEN); | ||
2336 | |||
2337 | sky2_write16(hw, WOL_CTRL_STAT, | ||
2338 | WOL_CTL_ENA_PME_ON_MAGIC_PKT | | ||
2339 | WOL_CTL_ENA_MAGIC_PKT_UNIT); | ||
2340 | } else | ||
2341 | sky2_write16(hw, WOL_CTRL_STAT, WOL_CTL_DEFAULT); | ||
2342 | |||
2343 | return 0; | ||
2344 | } | ||
2345 | #endif | ||
2346 | |||
2347 | |||
2348 | static struct ethtool_ops sky2_ethtool_ops = { | ||
2349 | .get_settings = sky2_get_settings, | ||
2350 | .set_settings = sky2_set_settings, | ||
2351 | .get_drvinfo = sky2_get_drvinfo, | ||
2352 | .get_msglevel = sky2_get_msglevel, | ||
2353 | .set_msglevel = sky2_set_msglevel, | ||
2354 | .get_link = ethtool_op_get_link, | ||
2355 | .get_sg = ethtool_op_get_sg, | ||
2356 | .set_sg = ethtool_op_set_sg, | ||
2357 | .get_tx_csum = ethtool_op_get_tx_csum, | ||
2358 | .set_tx_csum = ethtool_op_set_tx_csum, | ||
2359 | .get_tso = ethtool_op_get_tso, | ||
2360 | .set_tso = ethtool_op_set_tso, | ||
2361 | .get_rx_csum = sky2_get_rx_csum, | ||
2362 | .set_rx_csum = sky2_set_rx_csum, | ||
2363 | .get_strings = sky2_get_strings, | ||
2364 | .get_pauseparam = sky2_get_pauseparam, | ||
2365 | .set_pauseparam = sky2_set_pauseparam, | ||
2366 | #ifdef CONFIG_PM | ||
2367 | .get_wol = sky2_get_wol, | ||
2368 | .set_wol = sky2_set_wol, | ||
2369 | #endif | ||
2370 | .phys_id = sky2_phys_id, | ||
2371 | .get_stats_count = sky2_get_stats_count, | ||
2372 | .get_ethtool_stats = sky2_get_ethtool_stats, | ||
2373 | }; | ||
2374 | |||
2375 | /* Initialize network device */ | ||
2376 | static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw, | ||
2377 | unsigned port, int highmem) | ||
2378 | { | ||
2379 | struct sky2_port *sky2; | ||
2380 | struct net_device *dev = alloc_etherdev(sizeof(*sky2)); | ||
2381 | |||
2382 | if (!dev) { | ||
2383 | printk(KERN_ERR "sky2 etherdev alloc failed"); | ||
2384 | return NULL; | ||
2385 | } | ||
2386 | |||
2387 | SET_MODULE_OWNER(dev); | ||
2388 | SET_NETDEV_DEV(dev, &hw->pdev->dev); | ||
2389 | dev->open = sky2_up; | ||
2390 | dev->stop = sky2_down; | ||
2391 | dev->hard_start_xmit = sky2_xmit_frame; | ||
2392 | dev->get_stats = sky2_get_stats; | ||
2393 | dev->set_multicast_list = sky2_set_multicast; | ||
2394 | dev->set_mac_address = sky2_set_mac_address; | ||
2395 | dev->change_mtu = sky2_change_mtu; | ||
2396 | SET_ETHTOOL_OPS(dev, &sky2_ethtool_ops); | ||
2397 | dev->tx_timeout = sky2_tx_timeout; | ||
2398 | dev->watchdog_timeo = TX_WATCHDOG; | ||
2399 | if (port == 0) | ||
2400 | dev->poll = sky2_poll; | ||
2401 | dev->weight = NAPI_WEIGHT; | ||
2402 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
2403 | dev->poll_controller = sky2_netpoll; | ||
2404 | #endif | ||
2405 | dev->irq = hw->pdev->irq; | ||
2406 | |||
2407 | sky2 = netdev_priv(dev); | ||
2408 | sky2->netdev = dev; | ||
2409 | sky2->hw = hw; | ||
2410 | sky2->msg_enable = netif_msg_init(debug, default_msg); | ||
2411 | |||
2412 | spin_lock_init(&sky2->tx_lock); | ||
2413 | /* Auto speed and flow control */ | ||
2414 | sky2->autoneg = AUTONEG_ENABLE; | ||
2415 | sky2->tx_pause = 0; | ||
2416 | sky2->rx_pause = 1; | ||
2417 | sky2->duplex = -1; | ||
2418 | sky2->speed = -1; | ||
2419 | sky2->advertising = sky2_supported_modes(hw); | ||
2420 | sky2->rx_csum = 1; | ||
2421 | sky2->rx_ring_size = is_ec_a1(hw) ? MIN_RX_BUFFERS : MAX_RX_BUFFERS; | ||
2422 | tasklet_init(&sky2->phy_task, sky2_phy_task, (unsigned long) sky2); | ||
2423 | |||
2424 | hw->dev[port] = dev; | ||
2425 | |||
2426 | sky2->port = port; | ||
2427 | |||
2428 | dev->features |= NETIF_F_LLTX; | ||
2429 | if (highmem) | ||
2430 | dev->features |= NETIF_F_HIGHDMA; | ||
2431 | dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_TSO; | ||
2432 | |||
2433 | /* read the mac address */ | ||
2434 | memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port*8, ETH_ALEN); | ||
2435 | |||
2436 | /* device is off until link detection */ | ||
2437 | netif_carrier_off(dev); | ||
2438 | netif_stop_queue(dev); | ||
2439 | |||
2440 | return dev; | ||
2441 | } | ||
2442 | |||
2443 | static inline void sky2_show_addr(struct net_device *dev) | ||
2444 | { | ||
2445 | const struct sky2_port *sky2 = netdev_priv(dev); | ||
2446 | |||
2447 | if (netif_msg_probe(sky2)) | ||
2448 | printk(KERN_INFO PFX "%s: addr %02x:%02x:%02x:%02x:%02x:%02x\n", | ||
2449 | dev->name, | ||
2450 | dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], | ||
2451 | dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]); | ||
2452 | } | ||
2453 | |||
2454 | static int __devinit sky2_probe(struct pci_dev *pdev, | ||
2455 | const struct pci_device_id *ent) | ||
2456 | { | ||
2457 | struct net_device *dev, *dev1; | ||
2458 | struct sky2_hw *hw; | ||
2459 | int err, using_dac = 0; | ||
2460 | |||
2461 | if ((err = pci_enable_device(pdev))) { | ||
2462 | printk(KERN_ERR PFX "%s cannot enable PCI device\n", | ||
2463 | pci_name(pdev)); | ||
2464 | goto err_out; | ||
2465 | } | ||
2466 | |||
2467 | if ((err = pci_request_regions(pdev, DRV_NAME))) { | ||
2468 | printk(KERN_ERR PFX "%s cannot obtain PCI resources\n", | ||
2469 | pci_name(pdev)); | ||
2470 | goto err_out_disable_pdev; | ||
2471 | } | ||
2472 | |||
2473 | pci_set_master(pdev); | ||
2474 | |||
2475 | if (sizeof(dma_addr_t) > sizeof(u32)) { | ||
2476 | err = pci_set_dma_mask(pdev, DMA_64BIT_MASK); | ||
2477 | if (!err) | ||
2478 | using_dac = 1; | ||
2479 | } | ||
2480 | |||
2481 | if (!using_dac) { | ||
2482 | err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); | ||
2483 | if (err) { | ||
2484 | printk(KERN_ERR PFX "%s no usable DMA configuration\n", | ||
2485 | pci_name(pdev)); | ||
2486 | goto err_out_free_regions; | ||
2487 | } | ||
2488 | } | ||
2489 | |||
2490 | #ifdef __BIG_ENDIAN | ||
2491 | /* byte swap decriptors in hardware */ | ||
2492 | { | ||
2493 | u32 reg; | ||
2494 | |||
2495 | pci_read_config_dword(pdev, PCI_DEV_REG2, ®); | ||
2496 | reg |= PCI_REV_DESC; | ||
2497 | pci_write_config_dword(pdev, PCI_DEV_REG2, reg); | ||
2498 | } | ||
2499 | #endif | ||
2500 | |||
2501 | err = -ENOMEM; | ||
2502 | hw = kmalloc(sizeof(*hw), GFP_KERNEL); | ||
2503 | if (!hw) { | ||
2504 | printk(KERN_ERR PFX "%s: cannot allocate hardware struct\n", | ||
2505 | pci_name(pdev)); | ||
2506 | goto err_out_free_regions; | ||
2507 | } | ||
2508 | |||
2509 | memset(hw, 0, sizeof(*hw)); | ||
2510 | hw->pdev = pdev; | ||
2511 | spin_lock_init(&hw->phy_lock); | ||
2512 | |||
2513 | hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000); | ||
2514 | if (!hw->regs) { | ||
2515 | printk(KERN_ERR PFX "%s: cannot map device registers\n", | ||
2516 | pci_name(pdev)); | ||
2517 | goto err_out_free_hw; | ||
2518 | } | ||
2519 | |||
2520 | err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ, DRV_NAME, hw); | ||
2521 | if (err) { | ||
2522 | printk(KERN_ERR PFX "%s: cannot assign irq %d\n", | ||
2523 | pci_name(pdev), pdev->irq); | ||
2524 | goto err_out_iounmap; | ||
2525 | } | ||
2526 | pci_set_drvdata(pdev, hw); | ||
2527 | |||
2528 | err = sky2_reset(hw); | ||
2529 | if (err) | ||
2530 | goto err_out_free_irq; | ||
2531 | |||
2532 | printk(KERN_INFO PFX "addr 0x%lx irq %d chip 0x%x (%s) rev %d\n", | ||
2533 | pci_resource_start(pdev, 0), pdev->irq, | ||
2534 | hw->chip_id, chip_name(hw->chip_id), hw->chip_rev); | ||
2535 | |||
2536 | if ((dev = sky2_init_netdev(hw, 0, using_dac)) == NULL) | ||
2537 | goto err_out_free_pci; | ||
2538 | |||
2539 | if ((err = register_netdev(dev))) { | ||
2540 | printk(KERN_ERR PFX "%s: cannot register net device\n", | ||
2541 | pci_name(pdev)); | ||
2542 | goto err_out_free_netdev; | ||
2543 | } | ||
2544 | |||
2545 | sky2_show_addr(dev); | ||
2546 | |||
2547 | if (hw->ports > 1 && (dev1 = sky2_init_netdev(hw, 1, using_dac))) { | ||
2548 | if (register_netdev(dev1) == 0) | ||
2549 | sky2_show_addr(dev1); | ||
2550 | else { | ||
2551 | /* Failure to register second port need not be fatal */ | ||
2552 | printk(KERN_WARNING PFX "register of second port failed\n"); | ||
2553 | hw->dev[1] = NULL; | ||
2554 | free_netdev(dev1); | ||
2555 | } | ||
2556 | } | ||
2557 | |||
2558 | return 0; | ||
2559 | |||
2560 | err_out_free_netdev: | ||
2561 | free_netdev(dev); | ||
2562 | |||
2563 | err_out_free_irq: | ||
2564 | free_irq(pdev->irq, hw); | ||
2565 | err_out_free_pci: | ||
2566 | pci_free_consistent(hw->pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma); | ||
2567 | err_out_iounmap: | ||
2568 | iounmap(hw->regs); | ||
2569 | err_out_free_hw: | ||
2570 | kfree(hw); | ||
2571 | err_out_free_regions: | ||
2572 | pci_release_regions(pdev); | ||
2573 | err_out_disable_pdev: | ||
2574 | pci_disable_device(pdev); | ||
2575 | pci_set_drvdata(pdev, NULL); | ||
2576 | err_out: | ||
2577 | return err; | ||
2578 | } | ||
2579 | |||
2580 | static void __devexit sky2_remove(struct pci_dev *pdev) | ||
2581 | { | ||
2582 | struct sky2_hw *hw = pci_get_drvdata(pdev); | ||
2583 | struct net_device *dev0, *dev1; | ||
2584 | |||
2585 | if(!hw) | ||
2586 | return; | ||
2587 | |||
2588 | if ((dev1 = hw->dev[1])) | ||
2589 | unregister_netdev(dev1); | ||
2590 | dev0 = hw->dev[0]; | ||
2591 | unregister_netdev(dev0); | ||
2592 | |||
2593 | sky2_write16(hw, B0_Y2LED, LED_STAT_OFF); | ||
2594 | |||
2595 | free_irq(pdev->irq, hw); | ||
2596 | pci_free_consistent(pdev, STATUS_LE_BYTES, | ||
2597 | hw->st_le, hw->st_dma); | ||
2598 | pci_release_regions(pdev); | ||
2599 | pci_disable_device(pdev); | ||
2600 | if (dev1) | ||
2601 | free_netdev(dev1); | ||
2602 | free_netdev(dev0); | ||
2603 | iounmap(hw->regs); | ||
2604 | kfree(hw); | ||
2605 | pci_set_drvdata(pdev, NULL); | ||
2606 | } | ||
2607 | |||
2608 | #ifdef CONFIG_PM | ||
2609 | static int sky2_suspend(struct pci_dev *pdev, pm_message_t state) | ||
2610 | { | ||
2611 | struct sky2_hw *hw = pci_get_drvdata(pdev); | ||
2612 | int i, wol = 0; | ||
2613 | |||
2614 | for (i = 0; i < 2; i++) { | ||
2615 | struct net_device *dev = hw->dev[i]; | ||
2616 | |||
2617 | if (dev) { | ||
2618 | struct sky2_port *sky2 = netdev_priv(dev); | ||
2619 | if (netif_running(dev)) { | ||
2620 | netif_carrier_off(dev); | ||
2621 | sky2_down(dev); | ||
2622 | } | ||
2623 | netif_device_detach(dev); | ||
2624 | wol |= sky2->wol; | ||
2625 | } | ||
2626 | } | ||
2627 | |||
2628 | pci_save_state(pdev); | ||
2629 | pci_enable_wake(pdev, pci_choose_state(pdev, state), wol); | ||
2630 | pci_disable_device(pdev); | ||
2631 | pci_set_power_state(pdev, pci_choose_state(pdev, state)); | ||
2632 | |||
2633 | return 0; | ||
2634 | } | ||
2635 | |||
2636 | static int sky2_resume(struct pci_dev *pdev) | ||
2637 | { | ||
2638 | struct sky2_hw *hw = pci_get_drvdata(pdev); | ||
2639 | int i; | ||
2640 | |||
2641 | pci_set_power_state(pdev, PCI_D0); | ||
2642 | pci_restore_state(pdev); | ||
2643 | pci_enable_wake(pdev, PCI_D0, 0); | ||
2644 | |||
2645 | sky2_reset(hw); | ||
2646 | |||
2647 | for (i = 0; i < 2; i++) { | ||
2648 | struct net_device *dev = hw->dev[i]; | ||
2649 | if (dev) { | ||
2650 | netif_device_attach(dev); | ||
2651 | if (netif_running(dev)) | ||
2652 | sky2_up(dev); | ||
2653 | } | ||
2654 | } | ||
2655 | return 0; | ||
2656 | } | ||
2657 | #endif | ||
2658 | |||
2659 | static struct pci_driver sky2_driver = { | ||
2660 | .name = DRV_NAME, | ||
2661 | .id_table = sky2_id_table, | ||
2662 | .probe = sky2_probe, | ||
2663 | .remove = __devexit_p(sky2_remove), | ||
2664 | #ifdef CONFIG_PM | ||
2665 | .suspend = sky2_suspend, | ||
2666 | .resume = sky2_resume, | ||
2667 | #endif | ||
2668 | }; | ||
2669 | |||
2670 | static int __init sky2_init_module(void) | ||
2671 | { | ||
2672 | |||
2673 | return pci_module_init(&sky2_driver); | ||
2674 | } | ||
2675 | |||
2676 | static void __exit sky2_cleanup_module(void) | ||
2677 | { | ||
2678 | pci_unregister_driver(&sky2_driver); | ||
2679 | } | ||
2680 | |||
2681 | module_init(sky2_init_module); | ||
2682 | module_exit(sky2_cleanup_module); | ||
2683 | |||
2684 | MODULE_DESCRIPTION("Marvell Yukon 2 Gigabit Ethernet driver"); | ||
2685 | MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>"); | ||
2686 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h new file mode 100644 index 000000000000..d2a0ac2c53e7 --- /dev/null +++ b/drivers/net/sky2.h | |||
@@ -0,0 +1,1935 @@ | |||
1 | /* | ||
2 | * Definitions for the new Marvell Yukon 2 driver. | ||
3 | */ | ||
4 | #ifndef _SKY2_H | ||
5 | #define _SKY2_H | ||
6 | |||
7 | /* PCI config registers */ | ||
8 | #define PCI_DEV_REG1 0x40 | ||
9 | #define PCI_DEV_REG2 0x44 | ||
10 | #define PCI_DEV_STATUS 0x7c | ||
11 | #define PCI_OS_PCI_X (1<<26) | ||
12 | |||
13 | #define PEX_LNK_STAT 0xf2 | ||
14 | #define PEX_UNC_ERR_STAT 0x104 | ||
15 | #define PEX_DEV_CTRL 0xe8 | ||
16 | |||
17 | /* Yukon-2 */ | ||
18 | enum pci_dev_reg_1 { | ||
19 | PCI_Y2_PIG_ENA = 1<<31, /* Enable Plug-in-Go (YUKON-2) */ | ||
20 | PCI_Y2_DLL_DIS = 1<<30, /* Disable PCI DLL (YUKON-2) */ | ||
21 | PCI_Y2_PHY2_COMA = 1<<29, /* Set PHY 2 to Coma Mode (YUKON-2) */ | ||
22 | PCI_Y2_PHY1_COMA = 1<<28, /* Set PHY 1 to Coma Mode (YUKON-2) */ | ||
23 | PCI_Y2_PHY2_POWD = 1<<27, /* Set PHY 2 to Power Down (YUKON-2) */ | ||
24 | PCI_Y2_PHY1_POWD = 1<<26, /* Set PHY 1 to Power Down (YUKON-2) */ | ||
25 | }; | ||
26 | |||
27 | enum pci_dev_reg_2 { | ||
28 | PCI_VPD_WR_THR = 0xffL<<24, /* Bit 31..24: VPD Write Threshold */ | ||
29 | PCI_DEV_SEL = 0x7fL<<17, /* Bit 23..17: EEPROM Device Select */ | ||
30 | PCI_VPD_ROM_SZ = 7L<<14, /* Bit 16..14: VPD ROM Size */ | ||
31 | |||
32 | PCI_PATCH_DIR = 0xfL<<8, /* Bit 11.. 8: Ext Patches dir 3..0 */ | ||
33 | PCI_EXT_PATCHS = 0xfL<<4, /* Bit 7.. 4: Extended Patches 3..0 */ | ||
34 | PCI_EN_DUMMY_RD = 1<<3, /* Enable Dummy Read */ | ||
35 | PCI_REV_DESC = 1<<2, /* Reverse Desc. Bytes */ | ||
36 | |||
37 | PCI_USEDATA64 = 1<<0, /* Use 64Bit Data bus ext */ | ||
38 | }; | ||
39 | |||
40 | |||
41 | #define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \ | ||
42 | PCI_STATUS_SIG_SYSTEM_ERROR | \ | ||
43 | PCI_STATUS_REC_MASTER_ABORT | \ | ||
44 | PCI_STATUS_REC_TARGET_ABORT | \ | ||
45 | PCI_STATUS_PARITY) | ||
46 | |||
47 | enum pex_dev_ctrl { | ||
48 | PEX_DC_MAX_RRS_MSK = 7<<12, /* Bit 14..12: Max. Read Request Size */ | ||
49 | PEX_DC_EN_NO_SNOOP = 1<<11,/* Enable No Snoop */ | ||
50 | PEX_DC_EN_AUX_POW = 1<<10,/* Enable AUX Power */ | ||
51 | PEX_DC_EN_PHANTOM = 1<<9, /* Enable Phantom Functions */ | ||
52 | PEX_DC_EN_EXT_TAG = 1<<8, /* Enable Extended Tag Field */ | ||
53 | PEX_DC_MAX_PLS_MSK = 7<<5, /* Bit 7.. 5: Max. Payload Size Mask */ | ||
54 | PEX_DC_EN_REL_ORD = 1<<4, /* Enable Relaxed Ordering */ | ||
55 | PEX_DC_EN_UNS_RQ_RP = 1<<3, /* Enable Unsupported Request Reporting */ | ||
56 | PEX_DC_EN_FAT_ER_RP = 1<<2, /* Enable Fatal Error Reporting */ | ||
57 | PEX_DC_EN_NFA_ER_RP = 1<<1, /* Enable Non-Fatal Error Reporting */ | ||
58 | PEX_DC_EN_COR_ER_RP = 1<<0, /* Enable Correctable Error Reporting */ | ||
59 | }; | ||
60 | #define PEX_DC_MAX_RD_RQ_SIZE(x) (((x)<<12) & PEX_DC_MAX_RRS_MSK) | ||
61 | |||
62 | /* PEX_UNC_ERR_STAT PEX Uncorrectable Errors Status Register (Yukon-2) */ | ||
63 | enum pex_err { | ||
64 | PEX_UNSUP_REQ = 1<<20, /* Unsupported Request Error */ | ||
65 | |||
66 | PEX_MALFOR_TLP = 1<<18, /* Malformed TLP */ | ||
67 | |||
68 | PEX_UNEXP_COMP = 1<<16, /* Unexpected Completion */ | ||
69 | |||
70 | PEX_COMP_TO = 1<<14, /* Completion Timeout */ | ||
71 | PEX_FLOW_CTRL_P = 1<<13, /* Flow Control Protocol Error */ | ||
72 | PEX_POIS_TLP = 1<<12, /* Poisoned TLP */ | ||
73 | |||
74 | PEX_DATA_LINK_P = 1<<4, /* Data Link Protocol Error */ | ||
75 | PEX_FATAL_ERRORS= (PEX_MALFOR_TLP | PEX_FLOW_CTRL_P | PEX_DATA_LINK_P), | ||
76 | }; | ||
77 | |||
78 | |||
79 | enum csr_regs { | ||
80 | B0_RAP = 0x0000, | ||
81 | B0_CTST = 0x0004, | ||
82 | B0_Y2LED = 0x0005, | ||
83 | B0_POWER_CTRL = 0x0007, | ||
84 | B0_ISRC = 0x0008, | ||
85 | B0_IMSK = 0x000c, | ||
86 | B0_HWE_ISRC = 0x0010, | ||
87 | B0_HWE_IMSK = 0x0014, | ||
88 | B0_SP_ISRC = 0x0018, | ||
89 | B0_XM1_IMSK = 0x0020, | ||
90 | B0_XM1_ISRC = 0x0028, | ||
91 | B0_XM1_PHY_ADDR = 0x0030, | ||
92 | B0_XM1_PHY_DATA = 0x0034, | ||
93 | B0_XM2_IMSK = 0x0040, | ||
94 | B0_XM2_ISRC = 0x0048, | ||
95 | B0_XM2_PHY_ADDR = 0x0050, | ||
96 | B0_XM2_PHY_DATA = 0x0054, | ||
97 | B0_R1_CSR = 0x0060, | ||
98 | B0_R2_CSR = 0x0064, | ||
99 | B0_XS1_CSR = 0x0068, | ||
100 | B0_XA1_CSR = 0x006c, | ||
101 | B0_XS2_CSR = 0x0070, | ||
102 | B0_XA2_CSR = 0x0074, | ||
103 | |||
104 | /* Special ISR registers (Yukon-2 only) */ | ||
105 | B0_Y2_SP_ISRC2 = 0x001c, | ||
106 | B0_Y2_SP_ISRC3 = 0x0020, | ||
107 | B0_Y2_SP_EISR = 0x0024, | ||
108 | B0_Y2_SP_LISR = 0x0028, | ||
109 | B0_Y2_SP_ICR = 0x002c, | ||
110 | |||
111 | B2_MAC_1 = 0x0100, | ||
112 | B2_MAC_2 = 0x0108, | ||
113 | B2_MAC_3 = 0x0110, | ||
114 | B2_CONN_TYP = 0x0118, | ||
115 | B2_PMD_TYP = 0x0119, | ||
116 | B2_MAC_CFG = 0x011a, | ||
117 | B2_CHIP_ID = 0x011b, | ||
118 | B2_E_0 = 0x011c, | ||
119 | B2_E_1 = 0x011d, | ||
120 | B2_E_2 = 0x011e, | ||
121 | B2_Y2_CLK_GATE = 0x011d, | ||
122 | B2_Y2_HW_RES = 0x011e, | ||
123 | B2_E_3 = 0x011f, | ||
124 | B2_Y2_CLK_CTRL = 0x0120, | ||
125 | B2_LD_CTRL = 0x0128, | ||
126 | B2_LD_TEST = 0x0129, | ||
127 | B2_TI_INI = 0x0130, | ||
128 | B2_TI_VAL = 0x0134, | ||
129 | B2_TI_CTRL = 0x0138, | ||
130 | B2_TI_TEST = 0x0139, | ||
131 | B2_IRQM_INI = 0x0140, | ||
132 | B2_IRQM_VAL = 0x0144, | ||
133 | B2_IRQM_CTRL = 0x0148, | ||
134 | B2_IRQM_TEST = 0x0149, | ||
135 | B2_IRQM_MSK = 0x014c, | ||
136 | B2_IRQM_HWE_MSK = 0x0150, | ||
137 | B2_TST_CTRL1 = 0x0158, | ||
138 | B2_TST_CTRL2 = 0x0159, | ||
139 | B2_GP_IO = 0x015c, | ||
140 | B2_I2C_CTRL = 0x0160, | ||
141 | B2_I2C_DATA = 0x0164, | ||
142 | B2_I2C_IRQ = 0x0168, | ||
143 | B2_I2C_SW = 0x016c, | ||
144 | B2_BSC_INI = 0x0170, | ||
145 | B2_BSC_VAL = 0x0174, | ||
146 | B2_BSC_CTRL = 0x0178, | ||
147 | B2_BSC_STAT = 0x0179, | ||
148 | B2_BSC_TST = 0x017a, | ||
149 | |||
150 | B3_RAM_ADDR = 0x0180, | ||
151 | B3_RAM_DATA_LO = 0x0184, | ||
152 | B3_RAM_DATA_HI = 0x0188, | ||
153 | |||
154 | /* RAM Interface Registers */ | ||
155 | /* Yukon-2: use RAM_BUFFER() to access the RAM buffer */ | ||
156 | /* | ||
157 | * The HW-Spec. calls this registers Timeout Value 0..11. But this names are | ||
158 | * not usable in SW. Please notice these are NOT real timeouts, these are | ||
159 | * the number of qWords transferred continuously. | ||
160 | */ | ||
161 | #define RAM_BUFFER(port, reg) (reg | (port <<6)) | ||
162 | |||
163 | B3_RI_WTO_R1 = 0x0190, | ||
164 | B3_RI_WTO_XA1 = 0x0191, | ||
165 | B3_RI_WTO_XS1 = 0x0192, | ||
166 | B3_RI_RTO_R1 = 0x0193, | ||
167 | B3_RI_RTO_XA1 = 0x0194, | ||
168 | B3_RI_RTO_XS1 = 0x0195, | ||
169 | B3_RI_WTO_R2 = 0x0196, | ||
170 | B3_RI_WTO_XA2 = 0x0197, | ||
171 | B3_RI_WTO_XS2 = 0x0198, | ||
172 | B3_RI_RTO_R2 = 0x0199, | ||
173 | B3_RI_RTO_XA2 = 0x019a, | ||
174 | B3_RI_RTO_XS2 = 0x019b, | ||
175 | B3_RI_TO_VAL = 0x019c, | ||
176 | B3_RI_CTRL = 0x01a0, | ||
177 | B3_RI_TEST = 0x01a2, | ||
178 | B3_MA_TOINI_RX1 = 0x01b0, | ||
179 | B3_MA_TOINI_RX2 = 0x01b1, | ||
180 | B3_MA_TOINI_TX1 = 0x01b2, | ||
181 | B3_MA_TOINI_TX2 = 0x01b3, | ||
182 | B3_MA_TOVAL_RX1 = 0x01b4, | ||
183 | B3_MA_TOVAL_RX2 = 0x01b5, | ||
184 | B3_MA_TOVAL_TX1 = 0x01b6, | ||
185 | B3_MA_TOVAL_TX2 = 0x01b7, | ||
186 | B3_MA_TO_CTRL = 0x01b8, | ||
187 | B3_MA_TO_TEST = 0x01ba, | ||
188 | B3_MA_RCINI_RX1 = 0x01c0, | ||
189 | B3_MA_RCINI_RX2 = 0x01c1, | ||
190 | B3_MA_RCINI_TX1 = 0x01c2, | ||
191 | B3_MA_RCINI_TX2 = 0x01c3, | ||
192 | B3_MA_RCVAL_RX1 = 0x01c4, | ||
193 | B3_MA_RCVAL_RX2 = 0x01c5, | ||
194 | B3_MA_RCVAL_TX1 = 0x01c6, | ||
195 | B3_MA_RCVAL_TX2 = 0x01c7, | ||
196 | B3_MA_RC_CTRL = 0x01c8, | ||
197 | B3_MA_RC_TEST = 0x01ca, | ||
198 | B3_PA_TOINI_RX1 = 0x01d0, | ||
199 | B3_PA_TOINI_RX2 = 0x01d4, | ||
200 | B3_PA_TOINI_TX1 = 0x01d8, | ||
201 | B3_PA_TOINI_TX2 = 0x01dc, | ||
202 | B3_PA_TOVAL_RX1 = 0x01e0, | ||
203 | B3_PA_TOVAL_RX2 = 0x01e4, | ||
204 | B3_PA_TOVAL_TX1 = 0x01e8, | ||
205 | B3_PA_TOVAL_TX2 = 0x01ec, | ||
206 | B3_PA_CTRL = 0x01f0, | ||
207 | B3_PA_TEST = 0x01f2, | ||
208 | |||
209 | Y2_CFG_SPC = 0x1c00, | ||
210 | }; | ||
211 | |||
212 | /* Access pci config through board I/O */ | ||
213 | #define PCI_C(x) (Y2_CFG_SPC + (x)) | ||
214 | |||
215 | |||
216 | /* B0_CTST 16 bit Control/Status register */ | ||
217 | enum { | ||
218 | Y2_VMAIN_AVAIL = 1<<17, /* VMAIN available (YUKON-2 only) */ | ||
219 | Y2_VAUX_AVAIL = 1<<16,/* VAUX available (YUKON-2 only) */ | ||
220 | Y2_ASF_ENABLE = 1<<13,/* ASF Unit Enable (YUKON-2 only) */ | ||
221 | Y2_ASF_DISABLE = 1<<12,/* ASF Unit Disable (YUKON-2 only) */ | ||
222 | Y2_CLK_RUN_ENA = 1<<11,/* CLK_RUN Enable (YUKON-2 only) */ | ||
223 | Y2_CLK_RUN_DIS = 1<<10,/* CLK_RUN Disable (YUKON-2 only) */ | ||
224 | Y2_LED_STAT_ON = 1<<9, /* Status LED On (YUKON-2 only) */ | ||
225 | Y2_LED_STAT_OFF = 1<<8, /* Status LED Off (YUKON-2 only) */ | ||
226 | |||
227 | CS_BUS_CLOCK = 1<<9, /* Bus Clock 0/1 = 33/66 MHz */ | ||
228 | CS_BUS_SLOT_SZ = 1<<8, /* Slot Size 0/1 = 32/64 bit slot */ | ||
229 | CS_ST_SW_IRQ = 1<<7, /* Set IRQ SW Request */ | ||
230 | CS_CL_SW_IRQ = 1<<6, /* Clear IRQ SW Request */ | ||
231 | CS_STOP_DONE = 1<<5, /* Stop Master is finished */ | ||
232 | CS_STOP_MAST = 1<<4, /* Command Bit to stop the master */ | ||
233 | CS_MRST_CLR = 1<<3, /* Clear Master reset */ | ||
234 | CS_MRST_SET = 1<<2, /* Set Master reset */ | ||
235 | CS_RST_CLR = 1<<1, /* Clear Software reset */ | ||
236 | CS_RST_SET = 1, /* Set Software reset */ | ||
237 | |||
238 | /* B0_LED 8 Bit LED register */ | ||
239 | /* Bit 7.. 2: reserved */ | ||
240 | LED_STAT_ON = 1<<1, /* Status LED on */ | ||
241 | LED_STAT_OFF = 1, /* Status LED off */ | ||
242 | |||
243 | /* B0_POWER_CTRL 8 Bit Power Control reg (YUKON only) */ | ||
244 | PC_VAUX_ENA = 1<<7, /* Switch VAUX Enable */ | ||
245 | PC_VAUX_DIS = 1<<6, /* Switch VAUX Disable */ | ||
246 | PC_VCC_ENA = 1<<5, /* Switch VCC Enable */ | ||
247 | PC_VCC_DIS = 1<<4, /* Switch VCC Disable */ | ||
248 | PC_VAUX_ON = 1<<3, /* Switch VAUX On */ | ||
249 | PC_VAUX_OFF = 1<<2, /* Switch VAUX Off */ | ||
250 | PC_VCC_ON = 1<<1, /* Switch VCC On */ | ||
251 | PC_VCC_OFF = 1<<0, /* Switch VCC Off */ | ||
252 | }; | ||
253 | |||
254 | /* B2_IRQM_MSK 32 bit IRQ Moderation Mask */ | ||
255 | |||
256 | /* B0_Y2_SP_ISRC2 32 bit Special Interrupt Source Reg 2 */ | ||
257 | /* B0_Y2_SP_ISRC3 32 bit Special Interrupt Source Reg 3 */ | ||
258 | /* B0_Y2_SP_EISR 32 bit Enter ISR Reg */ | ||
259 | /* B0_Y2_SP_LISR 32 bit Leave ISR Reg */ | ||
260 | enum { | ||
261 | Y2_IS_HW_ERR = 1<<31, /* Interrupt HW Error */ | ||
262 | Y2_IS_STAT_BMU = 1<<30, /* Status BMU Interrupt */ | ||
263 | Y2_IS_ASF = 1<<29, /* ASF subsystem Interrupt */ | ||
264 | |||
265 | Y2_IS_POLL_CHK = 1<<27, /* Check IRQ from polling unit */ | ||
266 | Y2_IS_TWSI_RDY = 1<<26, /* IRQ on end of TWSI Tx */ | ||
267 | Y2_IS_IRQ_SW = 1<<25, /* SW forced IRQ */ | ||
268 | Y2_IS_TIMINT = 1<<24, /* IRQ from Timer */ | ||
269 | |||
270 | Y2_IS_IRQ_PHY2 = 1<<12, /* Interrupt from PHY 2 */ | ||
271 | Y2_IS_IRQ_MAC2 = 1<<11, /* Interrupt from MAC 2 */ | ||
272 | Y2_IS_CHK_RX2 = 1<<10, /* Descriptor error Rx 2 */ | ||
273 | Y2_IS_CHK_TXS2 = 1<<9, /* Descriptor error TXS 2 */ | ||
274 | Y2_IS_CHK_TXA2 = 1<<8, /* Descriptor error TXA 2 */ | ||
275 | |||
276 | Y2_IS_IRQ_PHY1 = 1<<4, /* Interrupt from PHY 1 */ | ||
277 | Y2_IS_IRQ_MAC1 = 1<<3, /* Interrupt from MAC 1 */ | ||
278 | Y2_IS_CHK_RX1 = 1<<2, /* Descriptor error Rx 1 */ | ||
279 | Y2_IS_CHK_TXS1 = 1<<1, /* Descriptor error TXS 1 */ | ||
280 | Y2_IS_CHK_TXA1 = 1<<0, /* Descriptor error TXA 1 */ | ||
281 | |||
282 | Y2_IS_BASE = Y2_IS_HW_ERR | Y2_IS_STAT_BMU | | ||
283 | Y2_IS_POLL_CHK | Y2_IS_TWSI_RDY | | ||
284 | Y2_IS_IRQ_SW | Y2_IS_TIMINT, | ||
285 | Y2_IS_PORT_1 = Y2_IS_IRQ_PHY1 | Y2_IS_IRQ_MAC1 | | ||
286 | Y2_IS_CHK_RX1 | Y2_IS_CHK_TXA1 | Y2_IS_CHK_TXS1, | ||
287 | Y2_IS_PORT_2 = Y2_IS_IRQ_PHY2 | Y2_IS_IRQ_MAC2 | | ||
288 | Y2_IS_CHK_RX2 | Y2_IS_CHK_TXA2 | Y2_IS_CHK_TXS2, | ||
289 | }; | ||
290 | |||
291 | /* B2_IRQM_HWE_MSK 32 bit IRQ Moderation HW Error Mask */ | ||
292 | enum { | ||
293 | IS_ERR_MSK = 0x00003fff,/* All Error bits */ | ||
294 | |||
295 | IS_IRQ_TIST_OV = 1<<13, /* Time Stamp Timer Overflow (YUKON only) */ | ||
296 | IS_IRQ_SENSOR = 1<<12, /* IRQ from Sensor (YUKON only) */ | ||
297 | IS_IRQ_MST_ERR = 1<<11, /* IRQ master error detected */ | ||
298 | IS_IRQ_STAT = 1<<10, /* IRQ status exception */ | ||
299 | IS_NO_STAT_M1 = 1<<9, /* No Rx Status from MAC 1 */ | ||
300 | IS_NO_STAT_M2 = 1<<8, /* No Rx Status from MAC 2 */ | ||
301 | IS_NO_TIST_M1 = 1<<7, /* No Time Stamp from MAC 1 */ | ||
302 | IS_NO_TIST_M2 = 1<<6, /* No Time Stamp from MAC 2 */ | ||
303 | IS_RAM_RD_PAR = 1<<5, /* RAM Read Parity Error */ | ||
304 | IS_RAM_WR_PAR = 1<<4, /* RAM Write Parity Error */ | ||
305 | IS_M1_PAR_ERR = 1<<3, /* MAC 1 Parity Error */ | ||
306 | IS_M2_PAR_ERR = 1<<2, /* MAC 2 Parity Error */ | ||
307 | IS_R1_PAR_ERR = 1<<1, /* Queue R1 Parity Error */ | ||
308 | IS_R2_PAR_ERR = 1<<0, /* Queue R2 Parity Error */ | ||
309 | }; | ||
310 | |||
311 | /* Hardware error interrupt mask for Yukon 2 */ | ||
312 | enum { | ||
313 | Y2_IS_TIST_OV = 1<<29,/* Time Stamp Timer overflow interrupt */ | ||
314 | Y2_IS_SENSOR = 1<<28, /* Sensor interrupt */ | ||
315 | Y2_IS_MST_ERR = 1<<27, /* Master error interrupt */ | ||
316 | Y2_IS_IRQ_STAT = 1<<26, /* Status exception interrupt */ | ||
317 | Y2_IS_PCI_EXP = 1<<25, /* PCI-Express interrupt */ | ||
318 | Y2_IS_PCI_NEXP = 1<<24, /* PCI-Express error similar to PCI error */ | ||
319 | /* Link 2 */ | ||
320 | Y2_IS_PAR_RD2 = 1<<13, /* Read RAM parity error interrupt */ | ||
321 | Y2_IS_PAR_WR2 = 1<<12, /* Write RAM parity error interrupt */ | ||
322 | Y2_IS_PAR_MAC2 = 1<<11, /* MAC hardware fault interrupt */ | ||
323 | Y2_IS_PAR_RX2 = 1<<10, /* Parity Error Rx Queue 2 */ | ||
324 | Y2_IS_TCP_TXS2 = 1<<9, /* TCP length mismatch sync Tx queue IRQ */ | ||
325 | Y2_IS_TCP_TXA2 = 1<<8, /* TCP length mismatch async Tx queue IRQ */ | ||
326 | /* Link 1 */ | ||
327 | Y2_IS_PAR_RD1 = 1<<5, /* Read RAM parity error interrupt */ | ||
328 | Y2_IS_PAR_WR1 = 1<<4, /* Write RAM parity error interrupt */ | ||
329 | Y2_IS_PAR_MAC1 = 1<<3, /* MAC hardware fault interrupt */ | ||
330 | Y2_IS_PAR_RX1 = 1<<2, /* Parity Error Rx Queue 1 */ | ||
331 | Y2_IS_TCP_TXS1 = 1<<1, /* TCP length mismatch sync Tx queue IRQ */ | ||
332 | Y2_IS_TCP_TXA1 = 1<<0, /* TCP length mismatch async Tx queue IRQ */ | ||
333 | |||
334 | Y2_HWE_L1_MASK = Y2_IS_PAR_RD1 | Y2_IS_PAR_WR1 | Y2_IS_PAR_MAC1 | | ||
335 | Y2_IS_PAR_RX1 | Y2_IS_TCP_TXS1| Y2_IS_TCP_TXA1, | ||
336 | Y2_HWE_L2_MASK = Y2_IS_PAR_RD2 | Y2_IS_PAR_WR2 | Y2_IS_PAR_MAC2 | | ||
337 | Y2_IS_PAR_RX2 | Y2_IS_TCP_TXS2| Y2_IS_TCP_TXA2, | ||
338 | |||
339 | Y2_HWE_ALL_MASK = Y2_IS_SENSOR | Y2_IS_MST_ERR | Y2_IS_IRQ_STAT | | ||
340 | Y2_IS_PCI_EXP | Y2_IS_PCI_NEXP | | ||
341 | Y2_HWE_L1_MASK | Y2_HWE_L2_MASK, | ||
342 | }; | ||
343 | |||
344 | /* B28_DPT_CTRL 8 bit Descriptor Poll Timer Ctrl Reg */ | ||
345 | enum { | ||
346 | DPT_START = 1<<1, | ||
347 | DPT_STOP = 1<<0, | ||
348 | }; | ||
349 | |||
350 | /* B2_TST_CTRL1 8 bit Test Control Register 1 */ | ||
351 | enum { | ||
352 | TST_FRC_DPERR_MR = 1<<7, /* force DATAPERR on MST RD */ | ||
353 | TST_FRC_DPERR_MW = 1<<6, /* force DATAPERR on MST WR */ | ||
354 | TST_FRC_DPERR_TR = 1<<5, /* force DATAPERR on TRG RD */ | ||
355 | TST_FRC_DPERR_TW = 1<<4, /* force DATAPERR on TRG WR */ | ||
356 | TST_FRC_APERR_M = 1<<3, /* force ADDRPERR on MST */ | ||
357 | TST_FRC_APERR_T = 1<<2, /* force ADDRPERR on TRG */ | ||
358 | TST_CFG_WRITE_ON = 1<<1, /* Enable Config Reg WR */ | ||
359 | TST_CFG_WRITE_OFF= 1<<0, /* Disable Config Reg WR */ | ||
360 | }; | ||
361 | |||
362 | /* B2_MAC_CFG 8 bit MAC Configuration / Chip Revision */ | ||
363 | enum { | ||
364 | CFG_CHIP_R_MSK = 0xf<<4, /* Bit 7.. 4: Chip Revision */ | ||
365 | /* Bit 3.. 2: reserved */ | ||
366 | CFG_DIS_M2_CLK = 1<<1, /* Disable Clock for 2nd MAC */ | ||
367 | CFG_SNG_MAC = 1<<0, /* MAC Config: 0=2 MACs / 1=1 MAC*/ | ||
368 | }; | ||
369 | |||
370 | /* B2_CHIP_ID 8 bit Chip Identification Number */ | ||
371 | enum { | ||
372 | CHIP_ID_GENESIS = 0x0a, /* Chip ID for GENESIS */ | ||
373 | CHIP_ID_YUKON = 0xb0, /* Chip ID for YUKON */ | ||
374 | CHIP_ID_YUKON_LITE = 0xb1, /* Chip ID for YUKON-Lite (Rev. A1-A3) */ | ||
375 | CHIP_ID_YUKON_LP = 0xb2, /* Chip ID for YUKON-LP */ | ||
376 | CHIP_ID_YUKON_XL = 0xb3, /* Chip ID for YUKON-2 XL */ | ||
377 | CHIP_ID_YUKON_EC = 0xb6, /* Chip ID for YUKON-2 EC */ | ||
378 | CHIP_ID_YUKON_FE = 0xb7, /* Chip ID for YUKON-2 FE */ | ||
379 | |||
380 | CHIP_REV_YU_EC_A1 = 0, /* Chip Rev. for Yukon-EC A1/A0 */ | ||
381 | CHIP_REV_YU_EC_A2 = 1, /* Chip Rev. for Yukon-EC A2 */ | ||
382 | CHIP_REV_YU_EC_A3 = 2, /* Chip Rev. for Yukon-EC A3 */ | ||
383 | }; | ||
384 | |||
385 | /* B2_Y2_CLK_GATE 8 bit Clock Gating (Yukon-2 only) */ | ||
386 | enum { | ||
387 | Y2_STATUS_LNK2_INAC = 1<<7, /* Status Link 2 inactiv (0 = activ) */ | ||
388 | Y2_CLK_GAT_LNK2_DIS = 1<<6, /* Disable clock gating Link 2 */ | ||
389 | Y2_COR_CLK_LNK2_DIS = 1<<5, /* Disable Core clock Link 2 */ | ||
390 | Y2_PCI_CLK_LNK2_DIS = 1<<4, /* Disable PCI clock Link 2 */ | ||
391 | Y2_STATUS_LNK1_INAC = 1<<3, /* Status Link 1 inactiv (0 = activ) */ | ||
392 | Y2_CLK_GAT_LNK1_DIS = 1<<2, /* Disable clock gating Link 1 */ | ||
393 | Y2_COR_CLK_LNK1_DIS = 1<<1, /* Disable Core clock Link 1 */ | ||
394 | Y2_PCI_CLK_LNK1_DIS = 1<<0, /* Disable PCI clock Link 1 */ | ||
395 | }; | ||
396 | |||
397 | /* B2_Y2_HW_RES 8 bit HW Resources (Yukon-2 only) */ | ||
398 | enum { | ||
399 | CFG_LED_MODE_MSK = 7<<2, /* Bit 4.. 2: LED Mode Mask */ | ||
400 | CFG_LINK_2_AVAIL = 1<<1, /* Link 2 available */ | ||
401 | CFG_LINK_1_AVAIL = 1<<0, /* Link 1 available */ | ||
402 | }; | ||
403 | #define CFG_LED_MODE(x) (((x) & CFG_LED_MODE_MSK) >> 2) | ||
404 | #define CFG_DUAL_MAC_MSK (CFG_LINK_2_AVAIL | CFG_LINK_1_AVAIL) | ||
405 | |||
406 | |||
407 | /* B2_Y2_CLK_CTRL 32 bit Clock Frequency Control Register (Yukon-2/EC) */ | ||
408 | enum { | ||
409 | Y2_CLK_DIV_VAL_MSK = 0xff<<16,/* Bit 23..16: Clock Divisor Value */ | ||
410 | #define Y2_CLK_DIV_VAL(x) (((x)<<16) & Y2_CLK_DIV_VAL_MSK) | ||
411 | Y2_CLK_DIV_VAL2_MSK = 7<<21, /* Bit 23..21: Clock Divisor Value */ | ||
412 | Y2_CLK_SELECT2_MSK = 0x1f<<16,/* Bit 20..16: Clock Select */ | ||
413 | #define Y2_CLK_DIV_VAL_2(x) (((x)<<21) & Y2_CLK_DIV_VAL2_MSK) | ||
414 | #define Y2_CLK_SEL_VAL_2(x) (((x)<<16) & Y2_CLK_SELECT2_MSK) | ||
415 | Y2_CLK_DIV_ENA = 1<<1, /* Enable Core Clock Division */ | ||
416 | Y2_CLK_DIV_DIS = 1<<0, /* Disable Core Clock Division */ | ||
417 | }; | ||
418 | |||
419 | /* B2_TI_CTRL 8 bit Timer control */ | ||
420 | /* B2_IRQM_CTRL 8 bit IRQ Moderation Timer Control */ | ||
421 | enum { | ||
422 | TIM_START = 1<<2, /* Start Timer */ | ||
423 | TIM_STOP = 1<<1, /* Stop Timer */ | ||
424 | TIM_CLR_IRQ = 1<<0, /* Clear Timer IRQ (!IRQM) */ | ||
425 | }; | ||
426 | |||
427 | /* B2_TI_TEST 8 Bit Timer Test */ | ||
428 | /* B2_IRQM_TEST 8 bit IRQ Moderation Timer Test */ | ||
429 | /* B28_DPT_TST 8 bit Descriptor Poll Timer Test Reg */ | ||
430 | enum { | ||
431 | TIM_T_ON = 1<<2, /* Test mode on */ | ||
432 | TIM_T_OFF = 1<<1, /* Test mode off */ | ||
433 | TIM_T_STEP = 1<<0, /* Test step */ | ||
434 | }; | ||
435 | |||
436 | /* B3_RAM_ADDR 32 bit RAM Address, to read or write */ | ||
437 | /* Bit 31..19: reserved */ | ||
438 | #define RAM_ADR_RAN 0x0007ffffL /* Bit 18.. 0: RAM Address Range */ | ||
439 | /* RAM Interface Registers */ | ||
440 | |||
441 | /* B3_RI_CTRL 16 bit RAM Iface Control Register */ | ||
442 | enum { | ||
443 | RI_CLR_RD_PERR = 1<<9, /* Clear IRQ RAM Read Parity Err */ | ||
444 | RI_CLR_WR_PERR = 1<<8, /* Clear IRQ RAM Write Parity Err*/ | ||
445 | |||
446 | RI_RST_CLR = 1<<1, /* Clear RAM Interface Reset */ | ||
447 | RI_RST_SET = 1<<0, /* Set RAM Interface Reset */ | ||
448 | }; | ||
449 | |||
450 | #define SK_RI_TO_53 36 /* RAM interface timeout */ | ||
451 | |||
452 | |||
453 | /* Port related registers FIFO, and Arbiter */ | ||
454 | #define SK_REG(port,reg) (((port)<<7)+(reg)) | ||
455 | |||
456 | /* Transmit Arbiter Registers MAC 1 and 2, use SK_REG() to access */ | ||
457 | /* TXA_ITI_INI 32 bit Tx Arb Interval Timer Init Val */ | ||
458 | /* TXA_ITI_VAL 32 bit Tx Arb Interval Timer Value */ | ||
459 | /* TXA_LIM_INI 32 bit Tx Arb Limit Counter Init Val */ | ||
460 | /* TXA_LIM_VAL 32 bit Tx Arb Limit Counter Value */ | ||
461 | |||
462 | #define TXA_MAX_VAL 0x00ffffffUL /* Bit 23.. 0: Max TXA Timer/Cnt Val */ | ||
463 | |||
464 | /* TXA_CTRL 8 bit Tx Arbiter Control Register */ | ||
465 | enum { | ||
466 | TXA_ENA_FSYNC = 1<<7, /* Enable force of sync Tx queue */ | ||
467 | TXA_DIS_FSYNC = 1<<6, /* Disable force of sync Tx queue */ | ||
468 | TXA_ENA_ALLOC = 1<<5, /* Enable alloc of free bandwidth */ | ||
469 | TXA_DIS_ALLOC = 1<<4, /* Disable alloc of free bandwidth */ | ||
470 | TXA_START_RC = 1<<3, /* Start sync Rate Control */ | ||
471 | TXA_STOP_RC = 1<<2, /* Stop sync Rate Control */ | ||
472 | TXA_ENA_ARB = 1<<1, /* Enable Tx Arbiter */ | ||
473 | TXA_DIS_ARB = 1<<0, /* Disable Tx Arbiter */ | ||
474 | }; | ||
475 | |||
476 | /* | ||
477 | * Bank 4 - 5 | ||
478 | */ | ||
479 | /* Transmit Arbiter Registers MAC 1 and 2, use SK_REG() to access */ | ||
480 | enum { | ||
481 | TXA_ITI_INI = 0x0200,/* 32 bit Tx Arb Interval Timer Init Val*/ | ||
482 | TXA_ITI_VAL = 0x0204,/* 32 bit Tx Arb Interval Timer Value */ | ||
483 | TXA_LIM_INI = 0x0208,/* 32 bit Tx Arb Limit Counter Init Val */ | ||
484 | TXA_LIM_VAL = 0x020c,/* 32 bit Tx Arb Limit Counter Value */ | ||
485 | TXA_CTRL = 0x0210,/* 8 bit Tx Arbiter Control Register */ | ||
486 | TXA_TEST = 0x0211,/* 8 bit Tx Arbiter Test Register */ | ||
487 | TXA_STAT = 0x0212,/* 8 bit Tx Arbiter Status Register */ | ||
488 | }; | ||
489 | |||
490 | |||
491 | enum { | ||
492 | B6_EXT_REG = 0x0300,/* External registers (GENESIS only) */ | ||
493 | B7_CFG_SPC = 0x0380,/* copy of the Configuration register */ | ||
494 | B8_RQ1_REGS = 0x0400,/* Receive Queue 1 */ | ||
495 | B8_RQ2_REGS = 0x0480,/* Receive Queue 2 */ | ||
496 | B8_TS1_REGS = 0x0600,/* Transmit sync queue 1 */ | ||
497 | B8_TA1_REGS = 0x0680,/* Transmit async queue 1 */ | ||
498 | B8_TS2_REGS = 0x0700,/* Transmit sync queue 2 */ | ||
499 | B8_TA2_REGS = 0x0780,/* Transmit sync queue 2 */ | ||
500 | B16_RAM_REGS = 0x0800,/* RAM Buffer Registers */ | ||
501 | }; | ||
502 | |||
503 | /* Queue Register Offsets, use Q_ADDR() to access */ | ||
504 | enum { | ||
505 | B8_Q_REGS = 0x0400, /* base of Queue registers */ | ||
506 | Q_D = 0x00, /* 8*32 bit Current Descriptor */ | ||
507 | Q_DA_L = 0x20, /* 32 bit Current Descriptor Address Low dWord */ | ||
508 | Q_DA_H = 0x24, /* 32 bit Current Descriptor Address High dWord */ | ||
509 | Q_AC_L = 0x28, /* 32 bit Current Address Counter Low dWord */ | ||
510 | Q_AC_H = 0x2c, /* 32 bit Current Address Counter High dWord */ | ||
511 | Q_BC = 0x30, /* 32 bit Current Byte Counter */ | ||
512 | Q_CSR = 0x34, /* 32 bit BMU Control/Status Register */ | ||
513 | Q_F = 0x38, /* 32 bit Flag Register */ | ||
514 | Q_T1 = 0x3c, /* 32 bit Test Register 1 */ | ||
515 | Q_T1_TR = 0x3c, /* 8 bit Test Register 1 Transfer SM */ | ||
516 | Q_T1_WR = 0x3d, /* 8 bit Test Register 1 Write Descriptor SM */ | ||
517 | Q_T1_RD = 0x3e, /* 8 bit Test Register 1 Read Descriptor SM */ | ||
518 | Q_T1_SV = 0x3f, /* 8 bit Test Register 1 Supervisor SM */ | ||
519 | Q_T2 = 0x40, /* 32 bit Test Register 2 */ | ||
520 | Q_T3 = 0x44, /* 32 bit Test Register 3 */ | ||
521 | |||
522 | /* Yukon-2 */ | ||
523 | Q_DONE = 0x24, /* 16 bit Done Index (Yukon-2 only) */ | ||
524 | Q_WM = 0x40, /* 16 bit FIFO Watermark */ | ||
525 | Q_AL = 0x42, /* 8 bit FIFO Alignment */ | ||
526 | Q_RSP = 0x44, /* 16 bit FIFO Read Shadow Pointer */ | ||
527 | Q_RSL = 0x46, /* 8 bit FIFO Read Shadow Level */ | ||
528 | Q_RP = 0x48, /* 8 bit FIFO Read Pointer */ | ||
529 | Q_RL = 0x4a, /* 8 bit FIFO Read Level */ | ||
530 | Q_WP = 0x4c, /* 8 bit FIFO Write Pointer */ | ||
531 | Q_WSP = 0x4d, /* 8 bit FIFO Write Shadow Pointer */ | ||
532 | Q_WL = 0x4e, /* 8 bit FIFO Write Level */ | ||
533 | Q_WSL = 0x4f, /* 8 bit FIFO Write Shadow Level */ | ||
534 | }; | ||
535 | #define Q_ADDR(reg, offs) (B8_Q_REGS + (reg) + (offs)) | ||
536 | |||
537 | |||
538 | /* Queue Prefetch Unit Offsets, use Y2_QADDR() to address (Yukon-2 only)*/ | ||
539 | enum { | ||
540 | Y2_B8_PREF_REGS = 0x0450, | ||
541 | |||
542 | PREF_UNIT_CTRL = 0x00, /* 32 bit Control register */ | ||
543 | PREF_UNIT_LAST_IDX = 0x04, /* 16 bit Last Index */ | ||
544 | PREF_UNIT_ADDR_LO = 0x08, /* 32 bit List start addr, low part */ | ||
545 | PREF_UNIT_ADDR_HI = 0x0c, /* 32 bit List start addr, high part*/ | ||
546 | PREF_UNIT_GET_IDX = 0x10, /* 16 bit Get Index */ | ||
547 | PREF_UNIT_PUT_IDX = 0x14, /* 16 bit Put Index */ | ||
548 | PREF_UNIT_FIFO_WP = 0x20, /* 8 bit FIFO write pointer */ | ||
549 | PREF_UNIT_FIFO_RP = 0x24, /* 8 bit FIFO read pointer */ | ||
550 | PREF_UNIT_FIFO_WM = 0x28, /* 8 bit FIFO watermark */ | ||
551 | PREF_UNIT_FIFO_LEV = 0x2c, /* 8 bit FIFO level */ | ||
552 | |||
553 | PREF_UNIT_MASK_IDX = 0x0fff, | ||
554 | }; | ||
555 | #define Y2_QADDR(q,reg) (Y2_B8_PREF_REGS + (q) + (reg)) | ||
556 | |||
557 | /* RAM Buffer Register Offsets */ | ||
558 | enum { | ||
559 | |||
560 | RB_START = 0x00,/* 32 bit RAM Buffer Start Address */ | ||
561 | RB_END = 0x04,/* 32 bit RAM Buffer End Address */ | ||
562 | RB_WP = 0x08,/* 32 bit RAM Buffer Write Pointer */ | ||
563 | RB_RP = 0x0c,/* 32 bit RAM Buffer Read Pointer */ | ||
564 | RB_RX_UTPP = 0x10,/* 32 bit Rx Upper Threshold, Pause Packet */ | ||
565 | RB_RX_LTPP = 0x14,/* 32 bit Rx Lower Threshold, Pause Packet */ | ||
566 | RB_RX_UTHP = 0x18,/* 32 bit Rx Upper Threshold, High Prio */ | ||
567 | RB_RX_LTHP = 0x1c,/* 32 bit Rx Lower Threshold, High Prio */ | ||
568 | /* 0x10 - 0x1f: reserved at Tx RAM Buffer Registers */ | ||
569 | RB_PC = 0x20,/* 32 bit RAM Buffer Packet Counter */ | ||
570 | RB_LEV = 0x24,/* 32 bit RAM Buffer Level Register */ | ||
571 | RB_CTRL = 0x28,/* 32 bit RAM Buffer Control Register */ | ||
572 | RB_TST1 = 0x29,/* 8 bit RAM Buffer Test Register 1 */ | ||
573 | RB_TST2 = 0x2a,/* 8 bit RAM Buffer Test Register 2 */ | ||
574 | }; | ||
575 | |||
576 | /* Receive and Transmit Queues */ | ||
577 | enum { | ||
578 | Q_R1 = 0x0000, /* Receive Queue 1 */ | ||
579 | Q_R2 = 0x0080, /* Receive Queue 2 */ | ||
580 | Q_XS1 = 0x0200, /* Synchronous Transmit Queue 1 */ | ||
581 | Q_XA1 = 0x0280, /* Asynchronous Transmit Queue 1 */ | ||
582 | Q_XS2 = 0x0300, /* Synchronous Transmit Queue 2 */ | ||
583 | Q_XA2 = 0x0380, /* Asynchronous Transmit Queue 2 */ | ||
584 | }; | ||
585 | |||
586 | /* Different PHY Types */ | ||
587 | enum { | ||
588 | PHY_ADDR_MARV = 0, | ||
589 | }; | ||
590 | |||
591 | #define RB_ADDR(offs, queue) (B16_RAM_REGS + (queue) + (offs)) | ||
592 | |||
593 | |||
594 | enum { | ||
595 | LNK_SYNC_INI = 0x0c30,/* 32 bit Link Sync Cnt Init Value */ | ||
596 | LNK_SYNC_VAL = 0x0c34,/* 32 bit Link Sync Cnt Current Value */ | ||
597 | LNK_SYNC_CTRL = 0x0c38,/* 8 bit Link Sync Cnt Control Register */ | ||
598 | LNK_SYNC_TST = 0x0c39,/* 8 bit Link Sync Cnt Test Register */ | ||
599 | |||
600 | LNK_LED_REG = 0x0c3c,/* 8 bit Link LED Register */ | ||
601 | |||
602 | /* Receive GMAC FIFO (YUKON and Yukon-2) */ | ||
603 | |||
604 | RX_GMF_EA = 0x0c40,/* 32 bit Rx GMAC FIFO End Address */ | ||
605 | RX_GMF_AF_THR = 0x0c44,/* 32 bit Rx GMAC FIFO Almost Full Thresh. */ | ||
606 | RX_GMF_CTRL_T = 0x0c48,/* 32 bit Rx GMAC FIFO Control/Test */ | ||
607 | RX_GMF_FL_MSK = 0x0c4c,/* 32 bit Rx GMAC FIFO Flush Mask */ | ||
608 | RX_GMF_FL_THR = 0x0c50,/* 32 bit Rx GMAC FIFO Flush Threshold */ | ||
609 | RX_GMF_TR_THR = 0x0c54,/* 32 bit Rx Truncation Threshold (Yukon-2) */ | ||
610 | |||
611 | RX_GMF_VLAN = 0x0c5c,/* 32 bit Rx VLAN Type Register (Yukon-2) */ | ||
612 | RX_GMF_WP = 0x0c60,/* 32 bit Rx GMAC FIFO Write Pointer */ | ||
613 | |||
614 | RX_GMF_WLEV = 0x0c68,/* 32 bit Rx GMAC FIFO Write Level */ | ||
615 | |||
616 | RX_GMF_RP = 0x0c70,/* 32 bit Rx GMAC FIFO Read Pointer */ | ||
617 | |||
618 | RX_GMF_RLEV = 0x0c78,/* 32 bit Rx GMAC FIFO Read Level */ | ||
619 | }; | ||
620 | |||
621 | |||
622 | /* Q_BC 32 bit Current Byte Counter */ | ||
623 | |||
624 | /* BMU Control Status Registers */ | ||
625 | /* B0_R1_CSR 32 bit BMU Ctrl/Stat Rx Queue 1 */ | ||
626 | /* B0_R2_CSR 32 bit BMU Ctrl/Stat Rx Queue 2 */ | ||
627 | /* B0_XA1_CSR 32 bit BMU Ctrl/Stat Sync Tx Queue 1 */ | ||
628 | /* B0_XS1_CSR 32 bit BMU Ctrl/Stat Async Tx Queue 1 */ | ||
629 | /* B0_XA2_CSR 32 bit BMU Ctrl/Stat Sync Tx Queue 2 */ | ||
630 | /* B0_XS2_CSR 32 bit BMU Ctrl/Stat Async Tx Queue 2 */ | ||
631 | /* Q_CSR 32 bit BMU Control/Status Register */ | ||
632 | |||
633 | /* Rx BMU Control / Status Registers (Yukon-2) */ | ||
634 | enum { | ||
635 | BMU_IDLE = 1<<31, /* BMU Idle State */ | ||
636 | BMU_RX_TCP_PKT = 1<<30, /* Rx TCP Packet (when RSS Hash enabled) */ | ||
637 | BMU_RX_IP_PKT = 1<<29, /* Rx IP Packet (when RSS Hash enabled) */ | ||
638 | |||
639 | BMU_ENA_RX_RSS_HASH = 1<<15, /* Enable Rx RSS Hash */ | ||
640 | BMU_DIS_RX_RSS_HASH = 1<<14, /* Disable Rx RSS Hash */ | ||
641 | BMU_ENA_RX_CHKSUM = 1<<13, /* Enable Rx TCP/IP Checksum Check */ | ||
642 | BMU_DIS_RX_CHKSUM = 1<<12, /* Disable Rx TCP/IP Checksum Check */ | ||
643 | BMU_CLR_IRQ_PAR = 1<<11, /* Clear IRQ on Parity errors (Rx) */ | ||
644 | BMU_CLR_IRQ_TCP = 1<<11, /* Clear IRQ on TCP segmen. error (Tx) */ | ||
645 | BMU_CLR_IRQ_CHK = 1<<10, /* Clear IRQ Check */ | ||
646 | BMU_STOP = 1<<9, /* Stop Rx/Tx Queue */ | ||
647 | BMU_START = 1<<8, /* Start Rx/Tx Queue */ | ||
648 | BMU_FIFO_OP_ON = 1<<7, /* FIFO Operational On */ | ||
649 | BMU_FIFO_OP_OFF = 1<<6, /* FIFO Operational Off */ | ||
650 | BMU_FIFO_ENA = 1<<5, /* Enable FIFO */ | ||
651 | BMU_FIFO_RST = 1<<4, /* Reset FIFO */ | ||
652 | BMU_OP_ON = 1<<3, /* BMU Operational On */ | ||
653 | BMU_OP_OFF = 1<<2, /* BMU Operational Off */ | ||
654 | BMU_RST_CLR = 1<<1, /* Clear BMU Reset (Enable) */ | ||
655 | BMU_RST_SET = 1<<0, /* Set BMU Reset */ | ||
656 | |||
657 | BMU_CLR_RESET = BMU_FIFO_RST | BMU_OP_OFF | BMU_RST_CLR, | ||
658 | BMU_OPER_INIT = BMU_CLR_IRQ_PAR | BMU_CLR_IRQ_CHK | BMU_START | | ||
659 | BMU_FIFO_ENA | BMU_OP_ON, | ||
660 | }; | ||
661 | |||
662 | /* Tx BMU Control / Status Registers (Yukon-2) */ | ||
663 | /* Bit 31: same as for Rx */ | ||
664 | enum { | ||
665 | BMU_TX_IPIDINCR_ON = 1<<13, /* Enable IP ID Increment */ | ||
666 | BMU_TX_IPIDINCR_OFF = 1<<12, /* Disable IP ID Increment */ | ||
667 | BMU_TX_CLR_IRQ_TCP = 1<<11, /* Clear IRQ on TCP segm. length mism. */ | ||
668 | }; | ||
669 | |||
670 | /* Queue Prefetch Unit Offsets, use Y2_QADDR() to address (Yukon-2 only)*/ | ||
671 | /* PREF_UNIT_CTRL 32 bit Prefetch Control register */ | ||
672 | enum { | ||
673 | PREF_UNIT_OP_ON = 1<<3, /* prefetch unit operational */ | ||
674 | PREF_UNIT_OP_OFF = 1<<2, /* prefetch unit not operational */ | ||
675 | PREF_UNIT_RST_CLR = 1<<1, /* Clear Prefetch Unit Reset */ | ||
676 | PREF_UNIT_RST_SET = 1<<0, /* Set Prefetch Unit Reset */ | ||
677 | }; | ||
678 | |||
679 | /* RAM Buffer Register Offsets, use RB_ADDR(Queue, Offs) to access */ | ||
680 | /* RB_START 32 bit RAM Buffer Start Address */ | ||
681 | /* RB_END 32 bit RAM Buffer End Address */ | ||
682 | /* RB_WP 32 bit RAM Buffer Write Pointer */ | ||
683 | /* RB_RP 32 bit RAM Buffer Read Pointer */ | ||
684 | /* RB_RX_UTPP 32 bit Rx Upper Threshold, Pause Pack */ | ||
685 | /* RB_RX_LTPP 32 bit Rx Lower Threshold, Pause Pack */ | ||
686 | /* RB_RX_UTHP 32 bit Rx Upper Threshold, High Prio */ | ||
687 | /* RB_RX_LTHP 32 bit Rx Lower Threshold, High Prio */ | ||
688 | /* RB_PC 32 bit RAM Buffer Packet Counter */ | ||
689 | /* RB_LEV 32 bit RAM Buffer Level Register */ | ||
690 | |||
691 | #define RB_MSK 0x0007ffff /* Bit 18.. 0: RAM Buffer Pointer Bits */ | ||
692 | /* RB_TST2 8 bit RAM Buffer Test Register 2 */ | ||
693 | /* RB_TST1 8 bit RAM Buffer Test Register 1 */ | ||
694 | |||
695 | /* RB_CTRL 8 bit RAM Buffer Control Register */ | ||
696 | enum { | ||
697 | RB_ENA_STFWD = 1<<5, /* Enable Store & Forward */ | ||
698 | RB_DIS_STFWD = 1<<4, /* Disable Store & Forward */ | ||
699 | RB_ENA_OP_MD = 1<<3, /* Enable Operation Mode */ | ||
700 | RB_DIS_OP_MD = 1<<2, /* Disable Operation Mode */ | ||
701 | RB_RST_CLR = 1<<1, /* Clear RAM Buf STM Reset */ | ||
702 | RB_RST_SET = 1<<0, /* Set RAM Buf STM Reset */ | ||
703 | }; | ||
704 | |||
705 | |||
706 | /* Transmit GMAC FIFO (YUKON only) */ | ||
707 | enum { | ||
708 | TX_GMF_EA = 0x0d40,/* 32 bit Tx GMAC FIFO End Address */ | ||
709 | TX_GMF_AE_THR = 0x0d44,/* 32 bit Tx GMAC FIFO Almost Empty Thresh.*/ | ||
710 | TX_GMF_CTRL_T = 0x0d48,/* 32 bit Tx GMAC FIFO Control/Test */ | ||
711 | |||
712 | TX_GMF_WP = 0x0d60,/* 32 bit Tx GMAC FIFO Write Pointer */ | ||
713 | TX_GMF_WSP = 0x0d64,/* 32 bit Tx GMAC FIFO Write Shadow Ptr. */ | ||
714 | TX_GMF_WLEV = 0x0d68,/* 32 bit Tx GMAC FIFO Write Level */ | ||
715 | |||
716 | TX_GMF_RP = 0x0d70,/* 32 bit Tx GMAC FIFO Read Pointer */ | ||
717 | TX_GMF_RSTP = 0x0d74,/* 32 bit Tx GMAC FIFO Restart Pointer */ | ||
718 | TX_GMF_RLEV = 0x0d78,/* 32 bit Tx GMAC FIFO Read Level */ | ||
719 | }; | ||
720 | |||
721 | /* Descriptor Poll Timer Registers */ | ||
722 | enum { | ||
723 | B28_DPT_INI = 0x0e00,/* 24 bit Descriptor Poll Timer Init Val */ | ||
724 | B28_DPT_VAL = 0x0e04,/* 24 bit Descriptor Poll Timer Curr Val */ | ||
725 | B28_DPT_CTRL = 0x0e08,/* 8 bit Descriptor Poll Timer Ctrl Reg */ | ||
726 | |||
727 | B28_DPT_TST = 0x0e0a,/* 8 bit Descriptor Poll Timer Test Reg */ | ||
728 | }; | ||
729 | |||
730 | /* Time Stamp Timer Registers (YUKON only) */ | ||
731 | enum { | ||
732 | GMAC_TI_ST_VAL = 0x0e14,/* 32 bit Time Stamp Timer Curr Val */ | ||
733 | GMAC_TI_ST_CTRL = 0x0e18,/* 8 bit Time Stamp Timer Ctrl Reg */ | ||
734 | GMAC_TI_ST_TST = 0x0e1a,/* 8 bit Time Stamp Timer Test Reg */ | ||
735 | }; | ||
736 | |||
737 | /* Polling Unit Registers (Yukon-2 only) */ | ||
738 | enum { | ||
739 | POLL_CTRL = 0x0e20, /* 32 bit Polling Unit Control Reg */ | ||
740 | POLL_LAST_IDX = 0x0e24,/* 16 bit Polling Unit List Last Index */ | ||
741 | |||
742 | POLL_LIST_ADDR_LO= 0x0e28,/* 32 bit Poll. List Start Addr (low) */ | ||
743 | POLL_LIST_ADDR_HI= 0x0e2c,/* 32 bit Poll. List Start Addr (high) */ | ||
744 | }; | ||
745 | |||
746 | /* ASF Subsystem Registers (Yukon-2 only) */ | ||
747 | enum { | ||
748 | B28_Y2_SMB_CONFIG = 0x0e40,/* 32 bit ASF SMBus Config Register */ | ||
749 | B28_Y2_SMB_CSD_REG = 0x0e44,/* 32 bit ASF SMB Control/Status/Data */ | ||
750 | B28_Y2_ASF_IRQ_V_BASE=0x0e60,/* 32 bit ASF IRQ Vector Base */ | ||
751 | |||
752 | B28_Y2_ASF_STAT_CMD= 0x0e68,/* 32 bit ASF Status and Command Reg */ | ||
753 | B28_Y2_ASF_HOST_COM= 0x0e6c,/* 32 bit ASF Host Communication Reg */ | ||
754 | B28_Y2_DATA_REG_1 = 0x0e70,/* 32 bit ASF/Host Data Register 1 */ | ||
755 | B28_Y2_DATA_REG_2 = 0x0e74,/* 32 bit ASF/Host Data Register 2 */ | ||
756 | B28_Y2_DATA_REG_3 = 0x0e78,/* 32 bit ASF/Host Data Register 3 */ | ||
757 | B28_Y2_DATA_REG_4 = 0x0e7c,/* 32 bit ASF/Host Data Register 4 */ | ||
758 | }; | ||
759 | |||
760 | /* Status BMU Registers (Yukon-2 only)*/ | ||
761 | enum { | ||
762 | STAT_CTRL = 0x0e80,/* 32 bit Status BMU Control Reg */ | ||
763 | STAT_LAST_IDX = 0x0e84,/* 16 bit Status BMU Last Index */ | ||
764 | |||
765 | STAT_LIST_ADDR_LO= 0x0e88,/* 32 bit Status List Start Addr (low) */ | ||
766 | STAT_LIST_ADDR_HI= 0x0e8c,/* 32 bit Status List Start Addr (high) */ | ||
767 | STAT_TXA1_RIDX = 0x0e90,/* 16 bit Status TxA1 Report Index Reg */ | ||
768 | STAT_TXS1_RIDX = 0x0e92,/* 16 bit Status TxS1 Report Index Reg */ | ||
769 | STAT_TXA2_RIDX = 0x0e94,/* 16 bit Status TxA2 Report Index Reg */ | ||
770 | STAT_TXS2_RIDX = 0x0e96,/* 16 bit Status TxS2 Report Index Reg */ | ||
771 | STAT_TX_IDX_TH = 0x0e98,/* 16 bit Status Tx Index Threshold Reg */ | ||
772 | STAT_PUT_IDX = 0x0e9c,/* 16 bit Status Put Index Reg */ | ||
773 | |||
774 | /* FIFO Control/Status Registers (Yukon-2 only)*/ | ||
775 | STAT_FIFO_WP = 0x0ea0,/* 8 bit Status FIFO Write Pointer Reg */ | ||
776 | STAT_FIFO_RP = 0x0ea4,/* 8 bit Status FIFO Read Pointer Reg */ | ||
777 | STAT_FIFO_RSP = 0x0ea6,/* 8 bit Status FIFO Read Shadow Ptr */ | ||
778 | STAT_FIFO_LEVEL = 0x0ea8,/* 8 bit Status FIFO Level Reg */ | ||
779 | STAT_FIFO_SHLVL = 0x0eaa,/* 8 bit Status FIFO Shadow Level Reg */ | ||
780 | STAT_FIFO_WM = 0x0eac,/* 8 bit Status FIFO Watermark Reg */ | ||
781 | STAT_FIFO_ISR_WM= 0x0ead,/* 8 bit Status FIFO ISR Watermark Reg */ | ||
782 | |||
783 | /* Level and ISR Timer Registers (Yukon-2 only)*/ | ||
784 | STAT_LEV_TIMER_INI= 0x0eb0,/* 32 bit Level Timer Init. Value Reg */ | ||
785 | STAT_LEV_TIMER_CNT= 0x0eb4,/* 32 bit Level Timer Counter Reg */ | ||
786 | STAT_LEV_TIMER_CTRL= 0x0eb8,/* 8 bit Level Timer Control Reg */ | ||
787 | STAT_LEV_TIMER_TEST= 0x0eb9,/* 8 bit Level Timer Test Reg */ | ||
788 | STAT_TX_TIMER_INI = 0x0ec0,/* 32 bit Tx Timer Init. Value Reg */ | ||
789 | STAT_TX_TIMER_CNT = 0x0ec4,/* 32 bit Tx Timer Counter Reg */ | ||
790 | STAT_TX_TIMER_CTRL = 0x0ec8,/* 8 bit Tx Timer Control Reg */ | ||
791 | STAT_TX_TIMER_TEST = 0x0ec9,/* 8 bit Tx Timer Test Reg */ | ||
792 | STAT_ISR_TIMER_INI = 0x0ed0,/* 32 bit ISR Timer Init. Value Reg */ | ||
793 | STAT_ISR_TIMER_CNT = 0x0ed4,/* 32 bit ISR Timer Counter Reg */ | ||
794 | STAT_ISR_TIMER_CTRL= 0x0ed8,/* 8 bit ISR Timer Control Reg */ | ||
795 | STAT_ISR_TIMER_TEST= 0x0ed9,/* 8 bit ISR Timer Test Reg */ | ||
796 | |||
797 | ST_LAST_IDX_MASK = 0x007f,/* Last Index Mask */ | ||
798 | ST_TXRP_IDX_MASK = 0x0fff,/* Tx Report Index Mask */ | ||
799 | ST_TXTH_IDX_MASK = 0x0fff,/* Tx Threshold Index Mask */ | ||
800 | ST_WM_IDX_MASK = 0x3f,/* FIFO Watermark Index Mask */ | ||
801 | }; | ||
802 | |||
803 | enum { | ||
804 | LINKLED_OFF = 0x01, | ||
805 | LINKLED_ON = 0x02, | ||
806 | LINKLED_LINKSYNC_OFF = 0x04, | ||
807 | LINKLED_LINKSYNC_ON = 0x08, | ||
808 | LINKLED_BLINK_OFF = 0x10, | ||
809 | LINKLED_BLINK_ON = 0x20, | ||
810 | }; | ||
811 | |||
812 | /* GMAC and GPHY Control Registers (YUKON only) */ | ||
813 | enum { | ||
814 | GMAC_CTRL = 0x0f00,/* 32 bit GMAC Control Reg */ | ||
815 | GPHY_CTRL = 0x0f04,/* 32 bit GPHY Control Reg */ | ||
816 | GMAC_IRQ_SRC = 0x0f08,/* 8 bit GMAC Interrupt Source Reg */ | ||
817 | GMAC_IRQ_MSK = 0x0f0c,/* 8 bit GMAC Interrupt Mask Reg */ | ||
818 | GMAC_LINK_CTRL = 0x0f10,/* 16 bit Link Control Reg */ | ||
819 | |||
820 | /* Wake-up Frame Pattern Match Control Registers (YUKON only) */ | ||
821 | |||
822 | WOL_REG_OFFS = 0x20,/* HW-Bug: Address is + 0x20 against spec. */ | ||
823 | |||
824 | WOL_CTRL_STAT = 0x0f20,/* 16 bit WOL Control/Status Reg */ | ||
825 | WOL_MATCH_CTL = 0x0f22,/* 8 bit WOL Match Control Reg */ | ||
826 | WOL_MATCH_RES = 0x0f23,/* 8 bit WOL Match Result Reg */ | ||
827 | WOL_MAC_ADDR = 0x0f24,/* 32 bit WOL MAC Address */ | ||
828 | WOL_PATT_PME = 0x0f2a,/* 8 bit WOL PME Match Enable (Yukon-2) */ | ||
829 | WOL_PATT_ASFM = 0x0f2b,/* 8 bit WOL ASF Match Enable (Yukon-2) */ | ||
830 | WOL_PATT_RPTR = 0x0f2c,/* 8 bit WOL Pattern Read Pointer */ | ||
831 | |||
832 | /* WOL Pattern Length Registers (YUKON only) */ | ||
833 | |||
834 | WOL_PATT_LEN_LO = 0x0f30,/* 32 bit WOL Pattern Length 3..0 */ | ||
835 | WOL_PATT_LEN_HI = 0x0f34,/* 24 bit WOL Pattern Length 6..4 */ | ||
836 | |||
837 | /* WOL Pattern Counter Registers (YUKON only) */ | ||
838 | |||
839 | WOL_PATT_CNT_0 = 0x0f38,/* 32 bit WOL Pattern Counter 3..0 */ | ||
840 | WOL_PATT_CNT_4 = 0x0f3c,/* 24 bit WOL Pattern Counter 6..4 */ | ||
841 | }; | ||
842 | |||
843 | enum { | ||
844 | WOL_PATT_RAM_1 = 0x1000,/* WOL Pattern RAM Link 1 */ | ||
845 | WOL_PATT_RAM_2 = 0x1400,/* WOL Pattern RAM Link 2 */ | ||
846 | }; | ||
847 | |||
848 | enum { | ||
849 | BASE_GMAC_1 = 0x2800,/* GMAC 1 registers */ | ||
850 | BASE_GMAC_2 = 0x3800,/* GMAC 2 registers */ | ||
851 | }; | ||
852 | |||
853 | /* | ||
854 | * Marvel-PHY Registers, indirect addressed over GMAC | ||
855 | */ | ||
856 | enum { | ||
857 | PHY_MARV_CTRL = 0x00,/* 16 bit r/w PHY Control Register */ | ||
858 | PHY_MARV_STAT = 0x01,/* 16 bit r/o PHY Status Register */ | ||
859 | PHY_MARV_ID0 = 0x02,/* 16 bit r/o PHY ID0 Register */ | ||
860 | PHY_MARV_ID1 = 0x03,/* 16 bit r/o PHY ID1 Register */ | ||
861 | PHY_MARV_AUNE_ADV = 0x04,/* 16 bit r/w Auto-Neg. Advertisement */ | ||
862 | PHY_MARV_AUNE_LP = 0x05,/* 16 bit r/o Link Part Ability Reg */ | ||
863 | PHY_MARV_AUNE_EXP = 0x06,/* 16 bit r/o Auto-Neg. Expansion Reg */ | ||
864 | PHY_MARV_NEPG = 0x07,/* 16 bit r/w Next Page Register */ | ||
865 | PHY_MARV_NEPG_LP = 0x08,/* 16 bit r/o Next Page Link Partner */ | ||
866 | /* Marvel-specific registers */ | ||
867 | PHY_MARV_1000T_CTRL = 0x09,/* 16 bit r/w 1000Base-T Control Reg */ | ||
868 | PHY_MARV_1000T_STAT = 0x0a,/* 16 bit r/o 1000Base-T Status Reg */ | ||
869 | PHY_MARV_EXT_STAT = 0x0f,/* 16 bit r/o Extended Status Reg */ | ||
870 | PHY_MARV_PHY_CTRL = 0x10,/* 16 bit r/w PHY Specific Ctrl Reg */ | ||
871 | PHY_MARV_PHY_STAT = 0x11,/* 16 bit r/o PHY Specific Stat Reg */ | ||
872 | PHY_MARV_INT_MASK = 0x12,/* 16 bit r/w Interrupt Mask Reg */ | ||
873 | PHY_MARV_INT_STAT = 0x13,/* 16 bit r/o Interrupt Status Reg */ | ||
874 | PHY_MARV_EXT_CTRL = 0x14,/* 16 bit r/w Ext. PHY Specific Ctrl */ | ||
875 | PHY_MARV_RXE_CNT = 0x15,/* 16 bit r/w Receive Error Counter */ | ||
876 | PHY_MARV_EXT_ADR = 0x16,/* 16 bit r/w Ext. Ad. for Cable Diag. */ | ||
877 | PHY_MARV_PORT_IRQ = 0x17,/* 16 bit r/o Port 0 IRQ (88E1111 only) */ | ||
878 | PHY_MARV_LED_CTRL = 0x18,/* 16 bit r/w LED Control Reg */ | ||
879 | PHY_MARV_LED_OVER = 0x19,/* 16 bit r/w Manual LED Override Reg */ | ||
880 | PHY_MARV_EXT_CTRL_2 = 0x1a,/* 16 bit r/w Ext. PHY Specific Ctrl 2 */ | ||
881 | PHY_MARV_EXT_P_STAT = 0x1b,/* 16 bit r/w Ext. PHY Spec. Stat Reg */ | ||
882 | PHY_MARV_CABLE_DIAG = 0x1c,/* 16 bit r/o Cable Diagnostic Reg */ | ||
883 | PHY_MARV_PAGE_ADDR = 0x1d,/* 16 bit r/w Extended Page Address Reg */ | ||
884 | PHY_MARV_PAGE_DATA = 0x1e,/* 16 bit r/w Extended Page Data Reg */ | ||
885 | |||
886 | /* for 10/100 Fast Ethernet PHY (88E3082 only) */ | ||
887 | PHY_MARV_FE_LED_PAR = 0x16,/* 16 bit r/w LED Parallel Select Reg. */ | ||
888 | PHY_MARV_FE_LED_SER = 0x17,/* 16 bit r/w LED Stream Select S. LED */ | ||
889 | PHY_MARV_FE_VCT_TX = 0x1a,/* 16 bit r/w VCT Reg. for TXP/N Pins */ | ||
890 | PHY_MARV_FE_VCT_RX = 0x1b,/* 16 bit r/o VCT Reg. for RXP/N Pins */ | ||
891 | PHY_MARV_FE_SPEC_2 = 0x1c,/* 16 bit r/w Specific Control Reg. 2 */ | ||
892 | }; | ||
893 | |||
894 | enum { | ||
895 | PHY_CT_RESET = 1<<15, /* Bit 15: (sc) clear all PHY related regs */ | ||
896 | PHY_CT_LOOP = 1<<14, /* Bit 14: enable Loopback over PHY */ | ||
897 | PHY_CT_SPS_LSB = 1<<13, /* Bit 13: Speed select, lower bit */ | ||
898 | PHY_CT_ANE = 1<<12, /* Bit 12: Auto-Negotiation Enabled */ | ||
899 | PHY_CT_PDOWN = 1<<11, /* Bit 11: Power Down Mode */ | ||
900 | PHY_CT_ISOL = 1<<10, /* Bit 10: Isolate Mode */ | ||
901 | PHY_CT_RE_CFG = 1<<9, /* Bit 9: (sc) Restart Auto-Negotiation */ | ||
902 | PHY_CT_DUP_MD = 1<<8, /* Bit 8: Duplex Mode */ | ||
903 | PHY_CT_COL_TST = 1<<7, /* Bit 7: Collision Test enabled */ | ||
904 | PHY_CT_SPS_MSB = 1<<6, /* Bit 6: Speed select, upper bit */ | ||
905 | }; | ||
906 | |||
907 | enum { | ||
908 | PHY_CT_SP1000 = PHY_CT_SPS_MSB, /* enable speed of 1000 Mbps */ | ||
909 | PHY_CT_SP100 = PHY_CT_SPS_LSB, /* enable speed of 100 Mbps */ | ||
910 | PHY_CT_SP10 = 0, /* enable speed of 10 Mbps */ | ||
911 | }; | ||
912 | |||
913 | enum { | ||
914 | PHY_ST_EXT_ST = 1<<8, /* Bit 8: Extended Status Present */ | ||
915 | |||
916 | PHY_ST_PRE_SUP = 1<<6, /* Bit 6: Preamble Suppression */ | ||
917 | PHY_ST_AN_OVER = 1<<5, /* Bit 5: Auto-Negotiation Over */ | ||
918 | PHY_ST_REM_FLT = 1<<4, /* Bit 4: Remote Fault Condition Occured */ | ||
919 | PHY_ST_AN_CAP = 1<<3, /* Bit 3: Auto-Negotiation Capability */ | ||
920 | PHY_ST_LSYNC = 1<<2, /* Bit 2: Link Synchronized */ | ||
921 | PHY_ST_JAB_DET = 1<<1, /* Bit 1: Jabber Detected */ | ||
922 | PHY_ST_EXT_REG = 1<<0, /* Bit 0: Extended Register available */ | ||
923 | }; | ||
924 | |||
925 | enum { | ||
926 | PHY_I1_OUI_MSK = 0x3f<<10, /* Bit 15..10: Organization Unique ID */ | ||
927 | PHY_I1_MOD_NUM = 0x3f<<4, /* Bit 9.. 4: Model Number */ | ||
928 | PHY_I1_REV_MSK = 0xf, /* Bit 3.. 0: Revision Number */ | ||
929 | }; | ||
930 | |||
931 | /* different Marvell PHY Ids */ | ||
932 | enum { | ||
933 | PHY_MARV_ID0_VAL= 0x0141, /* Marvell Unique Identifier */ | ||
934 | |||
935 | PHY_BCOM_ID1_A1 = 0x6041, | ||
936 | PHY_BCOM_ID1_B2 = 0x6043, | ||
937 | PHY_BCOM_ID1_C0 = 0x6044, | ||
938 | PHY_BCOM_ID1_C5 = 0x6047, | ||
939 | |||
940 | PHY_MARV_ID1_B0 = 0x0C23, /* Yukon (PHY 88E1011) */ | ||
941 | PHY_MARV_ID1_B2 = 0x0C25, /* Yukon-Plus (PHY 88E1011) */ | ||
942 | PHY_MARV_ID1_C2 = 0x0CC2, /* Yukon-EC (PHY 88E1111) */ | ||
943 | PHY_MARV_ID1_Y2 = 0x0C91, /* Yukon-2 (PHY 88E1112) */ | ||
944 | }; | ||
945 | |||
946 | /* Advertisement register bits */ | ||
947 | enum { | ||
948 | PHY_AN_NXT_PG = 1<<15, /* Bit 15: Request Next Page */ | ||
949 | PHY_AN_ACK = 1<<14, /* Bit 14: (ro) Acknowledge Received */ | ||
950 | PHY_AN_RF = 1<<13, /* Bit 13: Remote Fault Bits */ | ||
951 | |||
952 | PHY_AN_PAUSE_ASYM = 1<<11,/* Bit 11: Try for asymmetric */ | ||
953 | PHY_AN_PAUSE_CAP = 1<<10, /* Bit 10: Try for pause */ | ||
954 | PHY_AN_100BASE4 = 1<<9, /* Bit 9: Try for 100mbps 4k packets */ | ||
955 | PHY_AN_100FULL = 1<<8, /* Bit 8: Try for 100mbps full-duplex */ | ||
956 | PHY_AN_100HALF = 1<<7, /* Bit 7: Try for 100mbps half-duplex */ | ||
957 | PHY_AN_10FULL = 1<<6, /* Bit 6: Try for 10mbps full-duplex */ | ||
958 | PHY_AN_10HALF = 1<<5, /* Bit 5: Try for 10mbps half-duplex */ | ||
959 | PHY_AN_CSMA = 1<<0, /* Bit 0: Only selector supported */ | ||
960 | PHY_AN_SEL = 0x1f, /* Bit 4..0: Selector Field, 00001=Ethernet*/ | ||
961 | PHY_AN_FULL = PHY_AN_100FULL | PHY_AN_10FULL | PHY_AN_CSMA, | ||
962 | PHY_AN_ALL = PHY_AN_10HALF | PHY_AN_10FULL | | ||
963 | PHY_AN_100HALF | PHY_AN_100FULL, | ||
964 | }; | ||
965 | |||
966 | /***** PHY_BCOM_1000T_STAT 16 bit r/o 1000Base-T Status Reg *****/ | ||
967 | /***** PHY_MARV_1000T_STAT 16 bit r/o 1000Base-T Status Reg *****/ | ||
968 | enum { | ||
969 | PHY_B_1000S_MSF = 1<<15, /* Bit 15: Master/Slave Fault */ | ||
970 | PHY_B_1000S_MSR = 1<<14, /* Bit 14: Master/Slave Result */ | ||
971 | PHY_B_1000S_LRS = 1<<13, /* Bit 13: Local Receiver Status */ | ||
972 | PHY_B_1000S_RRS = 1<<12, /* Bit 12: Remote Receiver Status */ | ||
973 | PHY_B_1000S_LP_FD = 1<<11, /* Bit 11: Link Partner can FD */ | ||
974 | PHY_B_1000S_LP_HD = 1<<10, /* Bit 10: Link Partner can HD */ | ||
975 | /* Bit 9..8: reserved */ | ||
976 | PHY_B_1000S_IEC = 0xff, /* Bit 7..0: Idle Error Count */ | ||
977 | }; | ||
978 | |||
979 | /** Marvell-Specific */ | ||
980 | enum { | ||
981 | PHY_M_AN_NXT_PG = 1<<15, /* Request Next Page */ | ||
982 | PHY_M_AN_ACK = 1<<14, /* (ro) Acknowledge Received */ | ||
983 | PHY_M_AN_RF = 1<<13, /* Remote Fault */ | ||
984 | |||
985 | PHY_M_AN_ASP = 1<<11, /* Asymmetric Pause */ | ||
986 | PHY_M_AN_PC = 1<<10, /* MAC Pause implemented */ | ||
987 | PHY_M_AN_100_T4 = 1<<9, /* Not cap. 100Base-T4 (always 0) */ | ||
988 | PHY_M_AN_100_FD = 1<<8, /* Advertise 100Base-TX Full Duplex */ | ||
989 | PHY_M_AN_100_HD = 1<<7, /* Advertise 100Base-TX Half Duplex */ | ||
990 | PHY_M_AN_10_FD = 1<<6, /* Advertise 10Base-TX Full Duplex */ | ||
991 | PHY_M_AN_10_HD = 1<<5, /* Advertise 10Base-TX Half Duplex */ | ||
992 | PHY_M_AN_SEL_MSK =0x1f<<4, /* Bit 4.. 0: Selector Field Mask */ | ||
993 | }; | ||
994 | |||
995 | /* special defines for FIBER (88E1011S only) */ | ||
996 | enum { | ||
997 | PHY_M_AN_ASP_X = 1<<8, /* Asymmetric Pause */ | ||
998 | PHY_M_AN_PC_X = 1<<7, /* MAC Pause implemented */ | ||
999 | PHY_M_AN_1000X_AHD = 1<<6, /* Advertise 10000Base-X Half Duplex */ | ||
1000 | PHY_M_AN_1000X_AFD = 1<<5, /* Advertise 10000Base-X Full Duplex */ | ||
1001 | }; | ||
1002 | |||
1003 | /* Pause Bits (PHY_M_AN_ASP_X and PHY_M_AN_PC_X) encoding */ | ||
1004 | enum { | ||
1005 | PHY_M_P_NO_PAUSE_X = 0<<7,/* Bit 8.. 7: no Pause Mode */ | ||
1006 | PHY_M_P_SYM_MD_X = 1<<7, /* Bit 8.. 7: symmetric Pause Mode */ | ||
1007 | PHY_M_P_ASYM_MD_X = 2<<7,/* Bit 8.. 7: asymmetric Pause Mode */ | ||
1008 | PHY_M_P_BOTH_MD_X = 3<<7,/* Bit 8.. 7: both Pause Mode */ | ||
1009 | }; | ||
1010 | |||
1011 | /***** PHY_MARV_1000T_CTRL 16 bit r/w 1000Base-T Control Reg *****/ | ||
1012 | enum { | ||
1013 | PHY_M_1000C_TEST = 7<<13,/* Bit 15..13: Test Modes */ | ||
1014 | PHY_M_1000C_MSE = 1<<12, /* Manual Master/Slave Enable */ | ||
1015 | PHY_M_1000C_MSC = 1<<11, /* M/S Configuration (1=Master) */ | ||
1016 | PHY_M_1000C_MPD = 1<<10, /* Multi-Port Device */ | ||
1017 | PHY_M_1000C_AFD = 1<<9, /* Advertise Full Duplex */ | ||
1018 | PHY_M_1000C_AHD = 1<<8, /* Advertise Half Duplex */ | ||
1019 | }; | ||
1020 | |||
1021 | /***** PHY_MARV_PHY_CTRL 16 bit r/w PHY Specific Ctrl Reg *****/ | ||
1022 | enum { | ||
1023 | PHY_M_PC_TX_FFD_MSK = 3<<14,/* Bit 15..14: Tx FIFO Depth Mask */ | ||
1024 | PHY_M_PC_RX_FFD_MSK = 3<<12,/* Bit 13..12: Rx FIFO Depth Mask */ | ||
1025 | PHY_M_PC_ASS_CRS_TX = 1<<11, /* Assert CRS on Transmit */ | ||
1026 | PHY_M_PC_FL_GOOD = 1<<10, /* Force Link Good */ | ||
1027 | PHY_M_PC_EN_DET_MSK = 3<<8,/* Bit 9.. 8: Energy Detect Mask */ | ||
1028 | PHY_M_PC_ENA_EXT_D = 1<<7, /* Enable Ext. Distance (10BT) */ | ||
1029 | PHY_M_PC_MDIX_MSK = 3<<5,/* Bit 6.. 5: MDI/MDIX Config. Mask */ | ||
1030 | PHY_M_PC_DIS_125CLK = 1<<4, /* Disable 125 CLK */ | ||
1031 | PHY_M_PC_MAC_POW_UP = 1<<3, /* MAC Power up */ | ||
1032 | PHY_M_PC_SQE_T_ENA = 1<<2, /* SQE Test Enabled */ | ||
1033 | PHY_M_PC_POL_R_DIS = 1<<1, /* Polarity Reversal Disabled */ | ||
1034 | PHY_M_PC_DIS_JABBER = 1<<0, /* Disable Jabber */ | ||
1035 | }; | ||
1036 | |||
1037 | enum { | ||
1038 | PHY_M_PC_EN_DET = 2<<8, /* Energy Detect (Mode 1) */ | ||
1039 | PHY_M_PC_EN_DET_PLUS = 3<<8, /* Energy Detect Plus (Mode 2) */ | ||
1040 | }; | ||
1041 | |||
1042 | #define PHY_M_PC_MDI_XMODE(x) (((x)<<5) & PHY_M_PC_MDIX_MSK) | ||
1043 | |||
1044 | enum { | ||
1045 | PHY_M_PC_MAN_MDI = 0, /* 00 = Manual MDI configuration */ | ||
1046 | PHY_M_PC_MAN_MDIX = 1, /* 01 = Manual MDIX configuration */ | ||
1047 | PHY_M_PC_ENA_AUTO = 3, /* 11 = Enable Automatic Crossover */ | ||
1048 | }; | ||
1049 | |||
1050 | /* for 10/100 Fast Ethernet PHY (88E3082 only) */ | ||
1051 | enum { | ||
1052 | PHY_M_PC_ENA_DTE_DT = 1<<15, /* Enable Data Terminal Equ. (DTE) Detect */ | ||
1053 | PHY_M_PC_ENA_ENE_DT = 1<<14, /* Enable Energy Detect (sense & pulse) */ | ||
1054 | PHY_M_PC_DIS_NLP_CK = 1<<13, /* Disable Normal Link Puls (NLP) Check */ | ||
1055 | PHY_M_PC_ENA_LIP_NP = 1<<12, /* Enable Link Partner Next Page Reg. */ | ||
1056 | PHY_M_PC_DIS_NLP_GN = 1<<11, /* Disable Normal Link Puls Generation */ | ||
1057 | |||
1058 | PHY_M_PC_DIS_SCRAMB = 1<<9, /* Disable Scrambler */ | ||
1059 | PHY_M_PC_DIS_FEFI = 1<<8, /* Disable Far End Fault Indic. (FEFI) */ | ||
1060 | |||
1061 | PHY_M_PC_SH_TP_SEL = 1<<6, /* Shielded Twisted Pair Select */ | ||
1062 | PHY_M_PC_RX_FD_MSK = 3<<2,/* Bit 3.. 2: Rx FIFO Depth Mask */ | ||
1063 | }; | ||
1064 | |||
1065 | /***** PHY_MARV_PHY_STAT 16 bit r/o PHY Specific Status Reg *****/ | ||
1066 | enum { | ||
1067 | PHY_M_PS_SPEED_MSK = 3<<14, /* Bit 15..14: Speed Mask */ | ||
1068 | PHY_M_PS_SPEED_1000 = 1<<15, /* 10 = 1000 Mbps */ | ||
1069 | PHY_M_PS_SPEED_100 = 1<<14, /* 01 = 100 Mbps */ | ||
1070 | PHY_M_PS_SPEED_10 = 0, /* 00 = 10 Mbps */ | ||
1071 | PHY_M_PS_FULL_DUP = 1<<13, /* Full Duplex */ | ||
1072 | PHY_M_PS_PAGE_REC = 1<<12, /* Page Received */ | ||
1073 | PHY_M_PS_SPDUP_RES = 1<<11, /* Speed & Duplex Resolved */ | ||
1074 | PHY_M_PS_LINK_UP = 1<<10, /* Link Up */ | ||
1075 | PHY_M_PS_CABLE_MSK = 7<<7, /* Bit 9.. 7: Cable Length Mask */ | ||
1076 | PHY_M_PS_MDI_X_STAT = 1<<6, /* MDI Crossover Stat (1=MDIX) */ | ||
1077 | PHY_M_PS_DOWNS_STAT = 1<<5, /* Downshift Status (1=downsh.) */ | ||
1078 | PHY_M_PS_ENDET_STAT = 1<<4, /* Energy Detect Status (1=act) */ | ||
1079 | PHY_M_PS_TX_P_EN = 1<<3, /* Tx Pause Enabled */ | ||
1080 | PHY_M_PS_RX_P_EN = 1<<2, /* Rx Pause Enabled */ | ||
1081 | PHY_M_PS_POL_REV = 1<<1, /* Polarity Reversed */ | ||
1082 | PHY_M_PS_JABBER = 1<<0, /* Jabber */ | ||
1083 | }; | ||
1084 | |||
1085 | #define PHY_M_PS_PAUSE_MSK (PHY_M_PS_TX_P_EN | PHY_M_PS_RX_P_EN) | ||
1086 | |||
1087 | /* for 10/100 Fast Ethernet PHY (88E3082 only) */ | ||
1088 | enum { | ||
1089 | PHY_M_PS_DTE_DETECT = 1<<15, /* Data Terminal Equipment (DTE) Detected */ | ||
1090 | PHY_M_PS_RES_SPEED = 1<<14, /* Resolved Speed (1=100 Mbps, 0=10 Mbps */ | ||
1091 | }; | ||
1092 | |||
1093 | enum { | ||
1094 | PHY_M_IS_AN_ERROR = 1<<15, /* Auto-Negotiation Error */ | ||
1095 | PHY_M_IS_LSP_CHANGE = 1<<14, /* Link Speed Changed */ | ||
1096 | PHY_M_IS_DUP_CHANGE = 1<<13, /* Duplex Mode Changed */ | ||
1097 | PHY_M_IS_AN_PR = 1<<12, /* Page Received */ | ||
1098 | PHY_M_IS_AN_COMPL = 1<<11, /* Auto-Negotiation Completed */ | ||
1099 | PHY_M_IS_LST_CHANGE = 1<<10, /* Link Status Changed */ | ||
1100 | PHY_M_IS_SYMB_ERROR = 1<<9, /* Symbol Error */ | ||
1101 | PHY_M_IS_FALSE_CARR = 1<<8, /* False Carrier */ | ||
1102 | PHY_M_IS_FIFO_ERROR = 1<<7, /* FIFO Overflow/Underrun Error */ | ||
1103 | PHY_M_IS_MDI_CHANGE = 1<<6, /* MDI Crossover Changed */ | ||
1104 | PHY_M_IS_DOWNSH_DET = 1<<5, /* Downshift Detected */ | ||
1105 | PHY_M_IS_END_CHANGE = 1<<4, /* Energy Detect Changed */ | ||
1106 | |||
1107 | PHY_M_IS_DTE_CHANGE = 1<<2, /* DTE Power Det. Status Changed */ | ||
1108 | PHY_M_IS_POL_CHANGE = 1<<1, /* Polarity Changed */ | ||
1109 | PHY_M_IS_JABBER = 1<<0, /* Jabber */ | ||
1110 | |||
1111 | PHY_M_DEF_MSK = PHY_M_IS_LSP_CHANGE | PHY_M_IS_LST_CHANGE | ||
1112 | | PHY_M_IS_FIFO_ERROR, | ||
1113 | PHY_M_AN_MSK = PHY_M_IS_AN_ERROR | PHY_M_IS_AN_COMPL, | ||
1114 | }; | ||
1115 | |||
1116 | |||
1117 | /***** PHY_MARV_EXT_CTRL 16 bit r/w Ext. PHY Specific Ctrl *****/ | ||
1118 | enum { | ||
1119 | PHY_M_EC_ENA_BC_EXT = 1<<15, /* Enable Block Carr. Ext. (88E1111 only) */ | ||
1120 | PHY_M_EC_ENA_LIN_LB = 1<<14, /* Enable Line Loopback (88E1111 only) */ | ||
1121 | |||
1122 | PHY_M_EC_DIS_LINK_P = 1<<12, /* Disable Link Pulses (88E1111 only) */ | ||
1123 | PHY_M_EC_M_DSC_MSK = 3<<10, /* Bit 11..10: Master Downshift Counter */ | ||
1124 | /* (88E1011 only) */ | ||
1125 | PHY_M_EC_S_DSC_MSK = 3<<8,/* Bit 9.. 8: Slave Downshift Counter */ | ||
1126 | /* (88E1011 only) */ | ||
1127 | PHY_M_EC_M_DSC_MSK2 = 7<<9,/* Bit 11.. 9: Master Downshift Counter */ | ||
1128 | /* (88E1111 only) */ | ||
1129 | PHY_M_EC_DOWN_S_ENA = 1<<8, /* Downshift Enable (88E1111 only) */ | ||
1130 | /* !!! Errata in spec. (1 = disable) */ | ||
1131 | PHY_M_EC_RX_TIM_CT = 1<<7, /* RGMII Rx Timing Control*/ | ||
1132 | PHY_M_EC_MAC_S_MSK = 7<<4,/* Bit 6.. 4: Def. MAC interface speed */ | ||
1133 | PHY_M_EC_FIB_AN_ENA = 1<<3, /* Fiber Auto-Neg. Enable (88E1011S only) */ | ||
1134 | PHY_M_EC_DTE_D_ENA = 1<<2, /* DTE Detect Enable (88E1111 only) */ | ||
1135 | PHY_M_EC_TX_TIM_CT = 1<<1, /* RGMII Tx Timing Control */ | ||
1136 | PHY_M_EC_TRANS_DIS = 1<<0, /* Transmitter Disable (88E1111 only) */}; | ||
1137 | |||
1138 | #define PHY_M_EC_M_DSC(x) ((x)<<10 & PHY_M_EC_M_DSC_MSK) | ||
1139 | /* 00=1x; 01=2x; 10=3x; 11=4x */ | ||
1140 | #define PHY_M_EC_S_DSC(x) ((x)<<8 & PHY_M_EC_S_DSC_MSK) | ||
1141 | /* 00=dis; 01=1x; 10=2x; 11=3x */ | ||
1142 | #define PHY_M_EC_DSC_2(x) ((x)<<9 & PHY_M_EC_M_DSC_MSK2) | ||
1143 | /* 000=1x; 001=2x; 010=3x; 011=4x */ | ||
1144 | #define PHY_M_EC_MAC_S(x) ((x)<<4 & PHY_M_EC_MAC_S_MSK) | ||
1145 | /* 01X=0; 110=2.5; 111=25 (MHz) */ | ||
1146 | |||
1147 | /* for Yukon-2 Gigabit Ethernet PHY (88E1112 only) */ | ||
1148 | enum { | ||
1149 | PHY_M_PC_DIS_LINK_Pa = 1<<15,/* Disable Link Pulses */ | ||
1150 | PHY_M_PC_DSC_MSK = 7<<12,/* Bit 14..12: Downshift Counter */ | ||
1151 | PHY_M_PC_DOWN_S_ENA = 1<<11,/* Downshift Enable */ | ||
1152 | }; | ||
1153 | /* !!! Errata in spec. (1 = disable) */ | ||
1154 | |||
1155 | #define PHY_M_PC_DSC(x) (((x)<<12) & PHY_M_PC_DSC_MSK) | ||
1156 | /* 100=5x; 101=6x; 110=7x; 111=8x */ | ||
1157 | enum { | ||
1158 | MAC_TX_CLK_0_MHZ = 2, | ||
1159 | MAC_TX_CLK_2_5_MHZ = 6, | ||
1160 | MAC_TX_CLK_25_MHZ = 7, | ||
1161 | }; | ||
1162 | |||
1163 | /***** PHY_MARV_LED_CTRL 16 bit r/w LED Control Reg *****/ | ||
1164 | enum { | ||
1165 | PHY_M_LEDC_DIS_LED = 1<<15, /* Disable LED */ | ||
1166 | PHY_M_LEDC_PULS_MSK = 7<<12,/* Bit 14..12: Pulse Stretch Mask */ | ||
1167 | PHY_M_LEDC_F_INT = 1<<11, /* Force Interrupt */ | ||
1168 | PHY_M_LEDC_BL_R_MSK = 7<<8,/* Bit 10.. 8: Blink Rate Mask */ | ||
1169 | PHY_M_LEDC_DP_C_LSB = 1<<7, /* Duplex Control (LSB, 88E1111 only) */ | ||
1170 | PHY_M_LEDC_TX_C_LSB = 1<<6, /* Tx Control (LSB, 88E1111 only) */ | ||
1171 | PHY_M_LEDC_LK_C_MSK = 7<<3,/* Bit 5.. 3: Link Control Mask */ | ||
1172 | /* (88E1111 only) */ | ||
1173 | }; | ||
1174 | |||
1175 | enum { | ||
1176 | PHY_M_LEDC_LINK_MSK = 3<<3,/* Bit 4.. 3: Link Control Mask */ | ||
1177 | /* (88E1011 only) */ | ||
1178 | PHY_M_LEDC_DP_CTRL = 1<<2, /* Duplex Control */ | ||
1179 | PHY_M_LEDC_DP_C_MSB = 1<<2, /* Duplex Control (MSB, 88E1111 only) */ | ||
1180 | PHY_M_LEDC_RX_CTRL = 1<<1, /* Rx Activity / Link */ | ||
1181 | PHY_M_LEDC_TX_CTRL = 1<<0, /* Tx Activity / Link */ | ||
1182 | PHY_M_LEDC_TX_C_MSB = 1<<0, /* Tx Control (MSB, 88E1111 only) */ | ||
1183 | }; | ||
1184 | |||
1185 | #define PHY_M_LED_PULS_DUR(x) (((x)<<12) & PHY_M_LEDC_PULS_MSK) | ||
1186 | |||
1187 | /***** PHY_MARV_PHY_STAT (page 3)16 bit r/w Polarity Control Reg. *****/ | ||
1188 | enum { | ||
1189 | PHY_M_POLC_LS1M_MSK = 0xf<<12, /* Bit 15..12: LOS,STAT1 Mix % Mask */ | ||
1190 | PHY_M_POLC_IS0M_MSK = 0xf<<8, /* Bit 11.. 8: INIT,STAT0 Mix % Mask */ | ||
1191 | PHY_M_POLC_LOS_MSK = 0x3<<6, /* Bit 7.. 6: LOS Pol. Ctrl. Mask */ | ||
1192 | PHY_M_POLC_INIT_MSK = 0x3<<4, /* Bit 5.. 4: INIT Pol. Ctrl. Mask */ | ||
1193 | PHY_M_POLC_STA1_MSK = 0x3<<2, /* Bit 3.. 2: STAT1 Pol. Ctrl. Mask */ | ||
1194 | PHY_M_POLC_STA0_MSK = 0x3, /* Bit 1.. 0: STAT0 Pol. Ctrl. Mask */ | ||
1195 | }; | ||
1196 | |||
1197 | #define PHY_M_POLC_LS1_P_MIX(x) (((x)<<12) & PHY_M_POLC_LS1M_MSK) | ||
1198 | #define PHY_M_POLC_IS0_P_MIX(x) (((x)<<8) & PHY_M_POLC_IS0M_MSK) | ||
1199 | #define PHY_M_POLC_LOS_CTRL(x) (((x)<<6) & PHY_M_POLC_LOS_MSK) | ||
1200 | #define PHY_M_POLC_INIT_CTRL(x) (((x)<<4) & PHY_M_POLC_INIT_MSK) | ||
1201 | #define PHY_M_POLC_STA1_CTRL(x) (((x)<<2) & PHY_M_POLC_STA1_MSK) | ||
1202 | #define PHY_M_POLC_STA0_CTRL(x) (((x)<<0) & PHY_M_POLC_STA0_MSK) | ||
1203 | |||
1204 | enum { | ||
1205 | PULS_NO_STR = 0,/* no pulse stretching */ | ||
1206 | PULS_21MS = 1,/* 21 ms to 42 ms */ | ||
1207 | PULS_42MS = 2,/* 42 ms to 84 ms */ | ||
1208 | PULS_84MS = 3,/* 84 ms to 170 ms */ | ||
1209 | PULS_170MS = 4,/* 170 ms to 340 ms */ | ||
1210 | PULS_340MS = 5,/* 340 ms to 670 ms */ | ||
1211 | PULS_670MS = 6,/* 670 ms to 1.3 s */ | ||
1212 | PULS_1300MS = 7,/* 1.3 s to 2.7 s */ | ||
1213 | }; | ||
1214 | |||
1215 | #define PHY_M_LED_BLINK_RT(x) (((x)<<8) & PHY_M_LEDC_BL_R_MSK) | ||
1216 | |||
1217 | enum { | ||
1218 | BLINK_42MS = 0,/* 42 ms */ | ||
1219 | BLINK_84MS = 1,/* 84 ms */ | ||
1220 | BLINK_170MS = 2,/* 170 ms */ | ||
1221 | BLINK_340MS = 3,/* 340 ms */ | ||
1222 | BLINK_670MS = 4,/* 670 ms */ | ||
1223 | }; | ||
1224 | |||
1225 | /***** PHY_MARV_LED_OVER 16 bit r/w Manual LED Override Reg *****/ | ||
1226 | #define PHY_M_LED_MO_SGMII(x) ((x)<<14) /* Bit 15..14: SGMII AN Timer */ | ||
1227 | /* Bit 13..12: reserved */ | ||
1228 | #define PHY_M_LED_MO_DUP(x) ((x)<<10) /* Bit 11..10: Duplex */ | ||
1229 | #define PHY_M_LED_MO_10(x) ((x)<<8) /* Bit 9.. 8: Link 10 */ | ||
1230 | #define PHY_M_LED_MO_100(x) ((x)<<6) /* Bit 7.. 6: Link 100 */ | ||
1231 | #define PHY_M_LED_MO_1000(x) ((x)<<4) /* Bit 5.. 4: Link 1000 */ | ||
1232 | #define PHY_M_LED_MO_RX(x) ((x)<<2) /* Bit 3.. 2: Rx */ | ||
1233 | #define PHY_M_LED_MO_TX(x) ((x)<<0) /* Bit 1.. 0: Tx */ | ||
1234 | |||
1235 | enum { | ||
1236 | MO_LED_NORM = 0, | ||
1237 | MO_LED_BLINK = 1, | ||
1238 | MO_LED_OFF = 2, | ||
1239 | MO_LED_ON = 3, | ||
1240 | }; | ||
1241 | |||
1242 | /***** PHY_MARV_EXT_CTRL_2 16 bit r/w Ext. PHY Specific Ctrl 2 *****/ | ||
1243 | enum { | ||
1244 | PHY_M_EC2_FI_IMPED = 1<<6, /* Fiber Input Impedance */ | ||
1245 | PHY_M_EC2_FO_IMPED = 1<<5, /* Fiber Output Impedance */ | ||
1246 | PHY_M_EC2_FO_M_CLK = 1<<4, /* Fiber Mode Clock Enable */ | ||
1247 | PHY_M_EC2_FO_BOOST = 1<<3, /* Fiber Output Boost */ | ||
1248 | PHY_M_EC2_FO_AM_MSK = 7,/* Bit 2.. 0: Fiber Output Amplitude */ | ||
1249 | }; | ||
1250 | |||
1251 | /***** PHY_MARV_EXT_P_STAT 16 bit r/w Ext. PHY Specific Status *****/ | ||
1252 | enum { | ||
1253 | PHY_M_FC_AUTO_SEL = 1<<15, /* Fiber/Copper Auto Sel. Dis. */ | ||
1254 | PHY_M_FC_AN_REG_ACC = 1<<14, /* Fiber/Copper AN Reg. Access */ | ||
1255 | PHY_M_FC_RESOLUTION = 1<<13, /* Fiber/Copper Resolution */ | ||
1256 | PHY_M_SER_IF_AN_BP = 1<<12, /* Ser. IF AN Bypass Enable */ | ||
1257 | PHY_M_SER_IF_BP_ST = 1<<11, /* Ser. IF AN Bypass Status */ | ||
1258 | PHY_M_IRQ_POLARITY = 1<<10, /* IRQ polarity */ | ||
1259 | PHY_M_DIS_AUT_MED = 1<<9, /* Disable Aut. Medium Reg. Selection */ | ||
1260 | /* (88E1111 only) */ | ||
1261 | |||
1262 | PHY_M_UNDOC1 = 1<<7, /* undocumented bit !! */ | ||
1263 | PHY_M_DTE_POW_STAT = 1<<4, /* DTE Power Status (88E1111 only) */ | ||
1264 | PHY_M_MODE_MASK = 0xf, /* Bit 3.. 0: copy of HWCFG MODE[3:0] */ | ||
1265 | }; | ||
1266 | |||
1267 | /* for 10/100 Fast Ethernet PHY (88E3082 only) */ | ||
1268 | /***** PHY_MARV_FE_LED_PAR 16 bit r/w LED Parallel Select Reg. *****/ | ||
1269 | /* Bit 15..12: reserved (used internally) */ | ||
1270 | enum { | ||
1271 | PHY_M_FELP_LED2_MSK = 0xf<<8, /* Bit 11.. 8: LED2 Mask (LINK) */ | ||
1272 | PHY_M_FELP_LED1_MSK = 0xf<<4, /* Bit 7.. 4: LED1 Mask (ACT) */ | ||
1273 | PHY_M_FELP_LED0_MSK = 0xf, /* Bit 3.. 0: LED0 Mask (SPEED) */ | ||
1274 | }; | ||
1275 | |||
1276 | #define PHY_M_FELP_LED2_CTRL(x) (((x)<<8) & PHY_M_FELP_LED2_MSK) | ||
1277 | #define PHY_M_FELP_LED1_CTRL(x) (((x)<<4) & PHY_M_FELP_LED1_MSK) | ||
1278 | #define PHY_M_FELP_LED0_CTRL(x) (((x)<<0) & PHY_M_FELP_LED0_MSK) | ||
1279 | |||
1280 | enum { | ||
1281 | LED_PAR_CTRL_COLX = 0x00, | ||
1282 | LED_PAR_CTRL_ERROR = 0x01, | ||
1283 | LED_PAR_CTRL_DUPLEX = 0x02, | ||
1284 | LED_PAR_CTRL_DP_COL = 0x03, | ||
1285 | LED_PAR_CTRL_SPEED = 0x04, | ||
1286 | LED_PAR_CTRL_LINK = 0x05, | ||
1287 | LED_PAR_CTRL_TX = 0x06, | ||
1288 | LED_PAR_CTRL_RX = 0x07, | ||
1289 | LED_PAR_CTRL_ACT = 0x08, | ||
1290 | LED_PAR_CTRL_LNK_RX = 0x09, | ||
1291 | LED_PAR_CTRL_LNK_AC = 0x0a, | ||
1292 | LED_PAR_CTRL_ACT_BL = 0x0b, | ||
1293 | LED_PAR_CTRL_TX_BL = 0x0c, | ||
1294 | LED_PAR_CTRL_RX_BL = 0x0d, | ||
1295 | LED_PAR_CTRL_COL_BL = 0x0e, | ||
1296 | LED_PAR_CTRL_INACT = 0x0f | ||
1297 | }; | ||
1298 | |||
1299 | /*****,PHY_MARV_FE_SPEC_2 16 bit r/w Specific Control Reg. 2 *****/ | ||
1300 | enum { | ||
1301 | PHY_M_FESC_DIS_WAIT = 1<<2, /* Disable TDR Waiting Period */ | ||
1302 | PHY_M_FESC_ENA_MCLK = 1<<1, /* Enable MAC Rx Clock in sleep mode */ | ||
1303 | PHY_M_FESC_SEL_CL_A = 1<<0, /* Select Class A driver (100B-TX) */ | ||
1304 | }; | ||
1305 | |||
1306 | /* for Yukon-2 Gigabit Ethernet PHY (88E1112 only) */ | ||
1307 | /***** PHY_MARV_PHY_CTRL (page 2) 16 bit r/w MAC Specific Ctrl *****/ | ||
1308 | enum { | ||
1309 | PHY_M_MAC_MD_MSK = 7<<7, /* Bit 9.. 7: Mode Select Mask */ | ||
1310 | PHY_M_MAC_MD_AUTO = 3,/* Auto Copper/1000Base-X */ | ||
1311 | PHY_M_MAC_MD_COPPER = 5,/* Copper only */ | ||
1312 | PHY_M_MAC_MD_1000BX = 7,/* 1000Base-X only */ | ||
1313 | }; | ||
1314 | #define PHY_M_MAC_MODE_SEL(x) (((x)<<7) & PHY_M_MAC_MD_MSK) | ||
1315 | |||
1316 | /***** PHY_MARV_PHY_CTRL (page 3) 16 bit r/w LED Control Reg. *****/ | ||
1317 | enum { | ||
1318 | PHY_M_LEDC_LOS_MSK = 0xf<<12,/* Bit 15..12: LOS LED Ctrl. Mask */ | ||
1319 | PHY_M_LEDC_INIT_MSK = 0xf<<8, /* Bit 11.. 8: INIT LED Ctrl. Mask */ | ||
1320 | PHY_M_LEDC_STA1_MSK = 0xf<<4,/* Bit 7.. 4: STAT1 LED Ctrl. Mask */ | ||
1321 | PHY_M_LEDC_STA0_MSK = 0xf, /* Bit 3.. 0: STAT0 LED Ctrl. Mask */ | ||
1322 | }; | ||
1323 | |||
1324 | #define PHY_M_LEDC_LOS_CTRL(x) (((x)<<12) & PHY_M_LEDC_LOS_MSK) | ||
1325 | #define PHY_M_LEDC_INIT_CTRL(x) (((x)<<8) & PHY_M_LEDC_INIT_MSK) | ||
1326 | #define PHY_M_LEDC_STA1_CTRL(x) (((x)<<4) & PHY_M_LEDC_STA1_MSK) | ||
1327 | #define PHY_M_LEDC_STA0_CTRL(x) (((x)<<0) & PHY_M_LEDC_STA0_MSK) | ||
1328 | |||
1329 | /* GMAC registers */ | ||
1330 | /* Port Registers */ | ||
1331 | enum { | ||
1332 | GM_GP_STAT = 0x0000, /* 16 bit r/o General Purpose Status */ | ||
1333 | GM_GP_CTRL = 0x0004, /* 16 bit r/w General Purpose Control */ | ||
1334 | GM_TX_CTRL = 0x0008, /* 16 bit r/w Transmit Control Reg. */ | ||
1335 | GM_RX_CTRL = 0x000c, /* 16 bit r/w Receive Control Reg. */ | ||
1336 | GM_TX_FLOW_CTRL = 0x0010, /* 16 bit r/w Transmit Flow-Control */ | ||
1337 | GM_TX_PARAM = 0x0014, /* 16 bit r/w Transmit Parameter Reg. */ | ||
1338 | GM_SERIAL_MODE = 0x0018, /* 16 bit r/w Serial Mode Register */ | ||
1339 | /* Source Address Registers */ | ||
1340 | GM_SRC_ADDR_1L = 0x001c, /* 16 bit r/w Source Address 1 (low) */ | ||
1341 | GM_SRC_ADDR_1M = 0x0020, /* 16 bit r/w Source Address 1 (middle) */ | ||
1342 | GM_SRC_ADDR_1H = 0x0024, /* 16 bit r/w Source Address 1 (high) */ | ||
1343 | GM_SRC_ADDR_2L = 0x0028, /* 16 bit r/w Source Address 2 (low) */ | ||
1344 | GM_SRC_ADDR_2M = 0x002c, /* 16 bit r/w Source Address 2 (middle) */ | ||
1345 | GM_SRC_ADDR_2H = 0x0030, /* 16 bit r/w Source Address 2 (high) */ | ||
1346 | |||
1347 | /* Multicast Address Hash Registers */ | ||
1348 | GM_MC_ADDR_H1 = 0x0034, /* 16 bit r/w Multicast Address Hash 1 */ | ||
1349 | GM_MC_ADDR_H2 = 0x0038, /* 16 bit r/w Multicast Address Hash 2 */ | ||
1350 | GM_MC_ADDR_H3 = 0x003c, /* 16 bit r/w Multicast Address Hash 3 */ | ||
1351 | GM_MC_ADDR_H4 = 0x0040, /* 16 bit r/w Multicast Address Hash 4 */ | ||
1352 | |||
1353 | /* Interrupt Source Registers */ | ||
1354 | GM_TX_IRQ_SRC = 0x0044, /* 16 bit r/o Tx Overflow IRQ Source */ | ||
1355 | GM_RX_IRQ_SRC = 0x0048, /* 16 bit r/o Rx Overflow IRQ Source */ | ||
1356 | GM_TR_IRQ_SRC = 0x004c, /* 16 bit r/o Tx/Rx Over. IRQ Source */ | ||
1357 | |||
1358 | /* Interrupt Mask Registers */ | ||
1359 | GM_TX_IRQ_MSK = 0x0050, /* 16 bit r/w Tx Overflow IRQ Mask */ | ||
1360 | GM_RX_IRQ_MSK = 0x0054, /* 16 bit r/w Rx Overflow IRQ Mask */ | ||
1361 | GM_TR_IRQ_MSK = 0x0058, /* 16 bit r/w Tx/Rx Over. IRQ Mask */ | ||
1362 | |||
1363 | /* Serial Management Interface (SMI) Registers */ | ||
1364 | GM_SMI_CTRL = 0x0080, /* 16 bit r/w SMI Control Register */ | ||
1365 | GM_SMI_DATA = 0x0084, /* 16 bit r/w SMI Data Register */ | ||
1366 | GM_PHY_ADDR = 0x0088, /* 16 bit r/w GPHY Address Register */ | ||
1367 | }; | ||
1368 | |||
1369 | /* MIB Counters */ | ||
1370 | #define GM_MIB_CNT_BASE 0x0100 /* Base Address of MIB Counters */ | ||
1371 | #define GM_MIB_CNT_SIZE 44 /* Number of MIB Counters */ | ||
1372 | |||
1373 | /* | ||
1374 | * MIB Counters base address definitions (low word) - | ||
1375 | * use offset 4 for access to high word (32 bit r/o) | ||
1376 | */ | ||
1377 | enum { | ||
1378 | GM_RXF_UC_OK = GM_MIB_CNT_BASE + 0, /* Unicast Frames Received OK */ | ||
1379 | GM_RXF_BC_OK = GM_MIB_CNT_BASE + 8, /* Broadcast Frames Received OK */ | ||
1380 | GM_RXF_MPAUSE = GM_MIB_CNT_BASE + 16, /* Pause MAC Ctrl Frames Received */ | ||
1381 | GM_RXF_MC_OK = GM_MIB_CNT_BASE + 24, /* Multicast Frames Received OK */ | ||
1382 | GM_RXF_FCS_ERR = GM_MIB_CNT_BASE + 32, /* Rx Frame Check Seq. Error */ | ||
1383 | /* GM_MIB_CNT_BASE + 40: reserved */ | ||
1384 | GM_RXO_OK_LO = GM_MIB_CNT_BASE + 48, /* Octets Received OK Low */ | ||
1385 | GM_RXO_OK_HI = GM_MIB_CNT_BASE + 56, /* Octets Received OK High */ | ||
1386 | GM_RXO_ERR_LO = GM_MIB_CNT_BASE + 64, /* Octets Received Invalid Low */ | ||
1387 | GM_RXO_ERR_HI = GM_MIB_CNT_BASE + 72, /* Octets Received Invalid High */ | ||
1388 | GM_RXF_SHT = GM_MIB_CNT_BASE + 80, /* Frames <64 Byte Received OK */ | ||
1389 | GM_RXE_FRAG = GM_MIB_CNT_BASE + 88, /* Frames <64 Byte Received with FCS Err */ | ||
1390 | GM_RXF_64B = GM_MIB_CNT_BASE + 96, /* 64 Byte Rx Frame */ | ||
1391 | GM_RXF_127B = GM_MIB_CNT_BASE + 104, /* 65-127 Byte Rx Frame */ | ||
1392 | GM_RXF_255B = GM_MIB_CNT_BASE + 112, /* 128-255 Byte Rx Frame */ | ||
1393 | GM_RXF_511B = GM_MIB_CNT_BASE + 120, /* 256-511 Byte Rx Frame */ | ||
1394 | GM_RXF_1023B = GM_MIB_CNT_BASE + 128, /* 512-1023 Byte Rx Frame */ | ||
1395 | GM_RXF_1518B = GM_MIB_CNT_BASE + 136, /* 1024-1518 Byte Rx Frame */ | ||
1396 | GM_RXF_MAX_SZ = GM_MIB_CNT_BASE + 144, /* 1519-MaxSize Byte Rx Frame */ | ||
1397 | GM_RXF_LNG_ERR = GM_MIB_CNT_BASE + 152, /* Rx Frame too Long Error */ | ||
1398 | GM_RXF_JAB_PKT = GM_MIB_CNT_BASE + 160, /* Rx Jabber Packet Frame */ | ||
1399 | /* GM_MIB_CNT_BASE + 168: reserved */ | ||
1400 | GM_RXE_FIFO_OV = GM_MIB_CNT_BASE + 176, /* Rx FIFO overflow Event */ | ||
1401 | /* GM_MIB_CNT_BASE + 184: reserved */ | ||
1402 | GM_TXF_UC_OK = GM_MIB_CNT_BASE + 192, /* Unicast Frames Xmitted OK */ | ||
1403 | GM_TXF_BC_OK = GM_MIB_CNT_BASE + 200, /* Broadcast Frames Xmitted OK */ | ||
1404 | GM_TXF_MPAUSE = GM_MIB_CNT_BASE + 208, /* Pause MAC Ctrl Frames Xmitted */ | ||
1405 | GM_TXF_MC_OK = GM_MIB_CNT_BASE + 216, /* Multicast Frames Xmitted OK */ | ||
1406 | GM_TXO_OK_LO = GM_MIB_CNT_BASE + 224, /* Octets Transmitted OK Low */ | ||
1407 | GM_TXO_OK_HI = GM_MIB_CNT_BASE + 232, /* Octets Transmitted OK High */ | ||
1408 | GM_TXF_64B = GM_MIB_CNT_BASE + 240, /* 64 Byte Tx Frame */ | ||
1409 | GM_TXF_127B = GM_MIB_CNT_BASE + 248, /* 65-127 Byte Tx Frame */ | ||
1410 | GM_TXF_255B = GM_MIB_CNT_BASE + 256, /* 128-255 Byte Tx Frame */ | ||
1411 | GM_TXF_511B = GM_MIB_CNT_BASE + 264, /* 256-511 Byte Tx Frame */ | ||
1412 | GM_TXF_1023B = GM_MIB_CNT_BASE + 272, /* 512-1023 Byte Tx Frame */ | ||
1413 | GM_TXF_1518B = GM_MIB_CNT_BASE + 280, /* 1024-1518 Byte Tx Frame */ | ||
1414 | GM_TXF_MAX_SZ = GM_MIB_CNT_BASE + 288, /* 1519-MaxSize Byte Tx Frame */ | ||
1415 | |||
1416 | GM_TXF_COL = GM_MIB_CNT_BASE + 304, /* Tx Collision */ | ||
1417 | GM_TXF_LAT_COL = GM_MIB_CNT_BASE + 312, /* Tx Late Collision */ | ||
1418 | GM_TXF_ABO_COL = GM_MIB_CNT_BASE + 320, /* Tx aborted due to Exces. Col. */ | ||
1419 | GM_TXF_MUL_COL = GM_MIB_CNT_BASE + 328, /* Tx Multiple Collision */ | ||
1420 | GM_TXF_SNG_COL = GM_MIB_CNT_BASE + 336, /* Tx Single Collision */ | ||
1421 | GM_TXE_FIFO_UR = GM_MIB_CNT_BASE + 344, /* Tx FIFO Underrun Event */ | ||
1422 | }; | ||
1423 | |||
1424 | /* GMAC Bit Definitions */ | ||
1425 | /* GM_GP_STAT 16 bit r/o General Purpose Status Register */ | ||
1426 | enum { | ||
1427 | GM_GPSR_SPEED = 1<<15, /* Bit 15: Port Speed (1 = 100 Mbps) */ | ||
1428 | GM_GPSR_DUPLEX = 1<<14, /* Bit 14: Duplex Mode (1 = Full) */ | ||
1429 | GM_GPSR_FC_TX_DIS = 1<<13, /* Bit 13: Tx Flow-Control Mode Disabled */ | ||
1430 | GM_GPSR_LINK_UP = 1<<12, /* Bit 12: Link Up Status */ | ||
1431 | GM_GPSR_PAUSE = 1<<11, /* Bit 11: Pause State */ | ||
1432 | GM_GPSR_TX_ACTIVE = 1<<10, /* Bit 10: Tx in Progress */ | ||
1433 | GM_GPSR_EXC_COL = 1<<9, /* Bit 9: Excessive Collisions Occured */ | ||
1434 | GM_GPSR_LAT_COL = 1<<8, /* Bit 8: Late Collisions Occured */ | ||
1435 | |||
1436 | GM_GPSR_PHY_ST_CH = 1<<5, /* Bit 5: PHY Status Change */ | ||
1437 | GM_GPSR_GIG_SPEED = 1<<4, /* Bit 4: Gigabit Speed (1 = 1000 Mbps) */ | ||
1438 | GM_GPSR_PART_MODE = 1<<3, /* Bit 3: Partition mode */ | ||
1439 | GM_GPSR_FC_RX_DIS = 1<<2, /* Bit 2: Rx Flow-Control Mode Disabled */ | ||
1440 | GM_GPSR_PROM_EN = 1<<1, /* Bit 1: Promiscuous Mode Enabled */ | ||
1441 | }; | ||
1442 | |||
1443 | /* GM_GP_CTRL 16 bit r/w General Purpose Control Register */ | ||
1444 | enum { | ||
1445 | GM_GPCR_PROM_ENA = 1<<14, /* Bit 14: Enable Promiscuous Mode */ | ||
1446 | GM_GPCR_FC_TX_DIS = 1<<13, /* Bit 13: Disable Tx Flow-Control Mode */ | ||
1447 | GM_GPCR_TX_ENA = 1<<12, /* Bit 12: Enable Transmit */ | ||
1448 | GM_GPCR_RX_ENA = 1<<11, /* Bit 11: Enable Receive */ | ||
1449 | GM_GPCR_BURST_ENA = 1<<10, /* Bit 10: Enable Burst Mode */ | ||
1450 | GM_GPCR_LOOP_ENA = 1<<9, /* Bit 9: Enable MAC Loopback Mode */ | ||
1451 | GM_GPCR_PART_ENA = 1<<8, /* Bit 8: Enable Partition Mode */ | ||
1452 | GM_GPCR_GIGS_ENA = 1<<7, /* Bit 7: Gigabit Speed (1000 Mbps) */ | ||
1453 | GM_GPCR_FL_PASS = 1<<6, /* Bit 6: Force Link Pass */ | ||
1454 | GM_GPCR_DUP_FULL = 1<<5, /* Bit 5: Full Duplex Mode */ | ||
1455 | GM_GPCR_FC_RX_DIS = 1<<4, /* Bit 4: Disable Rx Flow-Control Mode */ | ||
1456 | GM_GPCR_SPEED_100 = 1<<3, /* Bit 3: Port Speed 100 Mbps */ | ||
1457 | GM_GPCR_AU_DUP_DIS = 1<<2, /* Bit 2: Disable Auto-Update Duplex */ | ||
1458 | GM_GPCR_AU_FCT_DIS = 1<<1, /* Bit 1: Disable Auto-Update Flow-C. */ | ||
1459 | GM_GPCR_AU_SPD_DIS = 1<<0, /* Bit 0: Disable Auto-Update Speed */ | ||
1460 | }; | ||
1461 | |||
1462 | #define GM_GPCR_SPEED_1000 (GM_GPCR_GIGS_ENA | GM_GPCR_SPEED_100) | ||
1463 | #define GM_GPCR_AU_ALL_DIS (GM_GPCR_AU_DUP_DIS | GM_GPCR_AU_FCT_DIS|GM_GPCR_AU_SPD_DIS) | ||
1464 | |||
1465 | /* GM_TX_CTRL 16 bit r/w Transmit Control Register */ | ||
1466 | enum { | ||
1467 | GM_TXCR_FORCE_JAM = 1<<15, /* Bit 15: Force Jam / Flow-Control */ | ||
1468 | GM_TXCR_CRC_DIS = 1<<14, /* Bit 14: Disable insertion of CRC */ | ||
1469 | GM_TXCR_PAD_DIS = 1<<13, /* Bit 13: Disable padding of packets */ | ||
1470 | GM_TXCR_COL_THR_MSK = 1<<10, /* Bit 12..10: Collision Threshold */ | ||
1471 | }; | ||
1472 | |||
1473 | #define TX_COL_THR(x) (((x)<<10) & GM_TXCR_COL_THR_MSK) | ||
1474 | #define TX_COL_DEF 0x04 | ||
1475 | |||
1476 | /* GM_RX_CTRL 16 bit r/w Receive Control Register */ | ||
1477 | enum { | ||
1478 | GM_RXCR_UCF_ENA = 1<<15, /* Bit 15: Enable Unicast filtering */ | ||
1479 | GM_RXCR_MCF_ENA = 1<<14, /* Bit 14: Enable Multicast filtering */ | ||
1480 | GM_RXCR_CRC_DIS = 1<<13, /* Bit 13: Remove 4-byte CRC */ | ||
1481 | GM_RXCR_PASS_FC = 1<<12, /* Bit 12: Pass FC packets to FIFO */ | ||
1482 | }; | ||
1483 | |||
1484 | /* GM_TX_PARAM 16 bit r/w Transmit Parameter Register */ | ||
1485 | enum { | ||
1486 | GM_TXPA_JAMLEN_MSK = 0x03<<14, /* Bit 15..14: Jam Length */ | ||
1487 | GM_TXPA_JAMIPG_MSK = 0x1f<<9, /* Bit 13..9: Jam IPG */ | ||
1488 | GM_TXPA_JAMDAT_MSK = 0x1f<<4, /* Bit 8..4: IPG Jam to Data */ | ||
1489 | GM_TXPA_BO_LIM_MSK = 0x0f, /* Bit 3.. 0: Backoff Limit Mask */ | ||
1490 | |||
1491 | TX_JAM_LEN_DEF = 0x03, | ||
1492 | TX_JAM_IPG_DEF = 0x0b, | ||
1493 | TX_IPG_JAM_DEF = 0x1c, | ||
1494 | TX_BOF_LIM_DEF = 0x04, | ||
1495 | }; | ||
1496 | |||
1497 | #define TX_JAM_LEN_VAL(x) (((x)<<14) & GM_TXPA_JAMLEN_MSK) | ||
1498 | #define TX_JAM_IPG_VAL(x) (((x)<<9) & GM_TXPA_JAMIPG_MSK) | ||
1499 | #define TX_IPG_JAM_DATA(x) (((x)<<4) & GM_TXPA_JAMDAT_MSK) | ||
1500 | #define TX_BACK_OFF_LIM(x) ((x) & GM_TXPA_BO_LIM_MSK) | ||
1501 | |||
1502 | |||
1503 | /* GM_SERIAL_MODE 16 bit r/w Serial Mode Register */ | ||
1504 | enum { | ||
1505 | GM_SMOD_DATABL_MSK = 0x1f<<11, /* Bit 15..11: Data Blinder (r/o) */ | ||
1506 | GM_SMOD_LIMIT_4 = 1<<10, /* Bit 10: 4 consecutive Tx trials */ | ||
1507 | GM_SMOD_VLAN_ENA = 1<<9, /* Bit 9: Enable VLAN (Max. Frame Len) */ | ||
1508 | GM_SMOD_JUMBO_ENA = 1<<8, /* Bit 8: Enable Jumbo (Max. Frame Len) */ | ||
1509 | GM_SMOD_IPG_MSK = 0x1f /* Bit 4..0: Inter-Packet Gap (IPG) */ | ||
1510 | }; | ||
1511 | |||
1512 | #define DATA_BLIND_VAL(x) (((x)<<11) & GM_SMOD_DATABL_MSK) | ||
1513 | #define DATA_BLIND_DEF 0x04 | ||
1514 | |||
1515 | #define IPG_DATA_VAL(x) (x & GM_SMOD_IPG_MSK) | ||
1516 | #define IPG_DATA_DEF 0x1e | ||
1517 | |||
1518 | /* GM_SMI_CTRL 16 bit r/w SMI Control Register */ | ||
1519 | enum { | ||
1520 | GM_SMI_CT_PHY_A_MSK = 0x1f<<11,/* Bit 15..11: PHY Device Address */ | ||
1521 | GM_SMI_CT_REG_A_MSK = 0x1f<<6,/* Bit 10.. 6: PHY Register Address */ | ||
1522 | GM_SMI_CT_OP_RD = 1<<5, /* Bit 5: OpCode Read (0=Write)*/ | ||
1523 | GM_SMI_CT_RD_VAL = 1<<4, /* Bit 4: Read Valid (Read completed) */ | ||
1524 | GM_SMI_CT_BUSY = 1<<3, /* Bit 3: Busy (Operation in progress) */ | ||
1525 | }; | ||
1526 | |||
1527 | #define GM_SMI_CT_PHY_AD(x) (((x)<<11) & GM_SMI_CT_PHY_A_MSK) | ||
1528 | #define GM_SMI_CT_REG_AD(x) (((x)<<6) & GM_SMI_CT_REG_A_MSK) | ||
1529 | |||
1530 | /* GM_PHY_ADDR 16 bit r/w GPHY Address Register */ | ||
1531 | enum { | ||
1532 | GM_PAR_MIB_CLR = 1<<5, /* Bit 5: Set MIB Clear Counter Mode */ | ||
1533 | GM_PAR_MIB_TST = 1<<4, /* Bit 4: MIB Load Counter (Test Mode) */ | ||
1534 | }; | ||
1535 | |||
1536 | /* Receive Frame Status Encoding */ | ||
1537 | enum { | ||
1538 | GMR_FS_LEN = 0xffff<<16, /* Bit 31..16: Rx Frame Length */ | ||
1539 | GMR_FS_VLAN = 1<<13, /* Bit 13: VLAN Packet */ | ||
1540 | GMR_FS_JABBER = 1<<12, /* Bit 12: Jabber Packet */ | ||
1541 | GMR_FS_UN_SIZE = 1<<11, /* Bit 11: Undersize Packet */ | ||
1542 | GMR_FS_MC = 1<<10, /* Bit 10: Multicast Packet */ | ||
1543 | GMR_FS_BC = 1<<9, /* Bit 9: Broadcast Packet */ | ||
1544 | GMR_FS_RX_OK = 1<<8, /* Bit 8: Receive OK (Good Packet) */ | ||
1545 | GMR_FS_GOOD_FC = 1<<7, /* Bit 7: Good Flow-Control Packet */ | ||
1546 | GMR_FS_BAD_FC = 1<<6, /* Bit 6: Bad Flow-Control Packet */ | ||
1547 | GMR_FS_MII_ERR = 1<<5, /* Bit 5: MII Error */ | ||
1548 | GMR_FS_LONG_ERR = 1<<4, /* Bit 4: Too Long Packet */ | ||
1549 | GMR_FS_FRAGMENT = 1<<3, /* Bit 3: Fragment */ | ||
1550 | |||
1551 | GMR_FS_CRC_ERR = 1<<1, /* Bit 1: CRC Error */ | ||
1552 | GMR_FS_RX_FF_OV = 1<<0, /* Bit 0: Rx FIFO Overflow */ | ||
1553 | |||
1554 | /* | ||
1555 | * GMR_FS_ANY_ERR (analogous to XMR_FS_ANY_ERR) | ||
1556 | */ | ||
1557 | GMR_FS_ANY_ERR = GMR_FS_RX_FF_OV | GMR_FS_CRC_ERR | | ||
1558 | GMR_FS_FRAGMENT | GMR_FS_LONG_ERR | | ||
1559 | GMR_FS_MII_ERR | GMR_FS_BAD_FC | GMR_FS_GOOD_FC | | ||
1560 | GMR_FS_UN_SIZE | GMR_FS_JABBER, | ||
1561 | /* Rx GMAC FIFO Flush Mask (default) */ | ||
1562 | RX_FF_FL_DEF_MSK = GMR_FS_ANY_ERR, | ||
1563 | }; | ||
1564 | |||
1565 | /* RX_GMF_CTRL_T 32 bit Rx GMAC FIFO Control/Test */ | ||
1566 | enum { | ||
1567 | GMF_WP_TST_ON = 1<<14, /* Write Pointer Test On */ | ||
1568 | GMF_WP_TST_OFF = 1<<13, /* Write Pointer Test Off */ | ||
1569 | GMF_WP_STEP = 1<<12, /* Write Pointer Step/Increment */ | ||
1570 | |||
1571 | GMF_RP_TST_ON = 1<<10, /* Read Pointer Test On */ | ||
1572 | GMF_RP_TST_OFF = 1<<9, /* Read Pointer Test Off */ | ||
1573 | GMF_RP_STEP = 1<<8, /* Read Pointer Step/Increment */ | ||
1574 | GMF_RX_F_FL_ON = 1<<7, /* Rx FIFO Flush Mode On */ | ||
1575 | GMF_RX_F_FL_OFF = 1<<6, /* Rx FIFO Flush Mode Off */ | ||
1576 | GMF_CLI_RX_FO = 1<<5, /* Clear IRQ Rx FIFO Overrun */ | ||
1577 | GMF_CLI_RX_FC = 1<<4, /* Clear IRQ Rx Frame Complete */ | ||
1578 | GMF_OPER_ON = 1<<3, /* Operational Mode On */ | ||
1579 | GMF_OPER_OFF = 1<<2, /* Operational Mode Off */ | ||
1580 | GMF_RST_CLR = 1<<1, /* Clear GMAC FIFO Reset */ | ||
1581 | GMF_RST_SET = 1<<0, /* Set GMAC FIFO Reset */ | ||
1582 | |||
1583 | RX_GMF_FL_THR_DEF = 0xa, /* flush threshold (default) */ | ||
1584 | }; | ||
1585 | |||
1586 | |||
1587 | /* TX_GMF_CTRL_T 32 bit Tx GMAC FIFO Control/Test */ | ||
1588 | enum { | ||
1589 | GMF_WSP_TST_ON = 1<<18,/* Write Shadow Pointer Test On */ | ||
1590 | GMF_WSP_TST_OFF = 1<<17,/* Write Shadow Pointer Test Off */ | ||
1591 | GMF_WSP_STEP = 1<<16,/* Write Shadow Pointer Step/Increment */ | ||
1592 | |||
1593 | GMF_CLI_TX_FU = 1<<6, /* Clear IRQ Tx FIFO Underrun */ | ||
1594 | GMF_CLI_TX_FC = 1<<5, /* Clear IRQ Tx Frame Complete */ | ||
1595 | GMF_CLI_TX_PE = 1<<4, /* Clear IRQ Tx Parity Error */ | ||
1596 | }; | ||
1597 | |||
1598 | /* GMAC_TI_ST_CTRL 8 bit Time Stamp Timer Ctrl Reg (YUKON only) */ | ||
1599 | enum { | ||
1600 | GMT_ST_START = 1<<2, /* Start Time Stamp Timer */ | ||
1601 | GMT_ST_STOP = 1<<1, /* Stop Time Stamp Timer */ | ||
1602 | GMT_ST_CLR_IRQ = 1<<0, /* Clear Time Stamp Timer IRQ */ | ||
1603 | }; | ||
1604 | |||
1605 | /* B28_Y2_ASF_STAT_CMD 32 bit ASF Status and Command Reg */ | ||
1606 | enum { | ||
1607 | Y2_ASF_OS_PRES = 1<<4, /* ASF operation system present */ | ||
1608 | Y2_ASF_RESET = 1<<3, /* ASF system in reset state */ | ||
1609 | Y2_ASF_RUNNING = 1<<2, /* ASF system operational */ | ||
1610 | Y2_ASF_CLR_HSTI = 1<<1, /* Clear ASF IRQ */ | ||
1611 | Y2_ASF_IRQ = 1<<0, /* Issue an IRQ to ASF system */ | ||
1612 | |||
1613 | Y2_ASF_UC_STATE = 3<<2, /* ASF uC State */ | ||
1614 | Y2_ASF_CLK_HALT = 0, /* ASF system clock stopped */ | ||
1615 | }; | ||
1616 | |||
1617 | /* B28_Y2_ASF_HOST_COM 32 bit ASF Host Communication Reg */ | ||
1618 | enum { | ||
1619 | Y2_ASF_CLR_ASFI = 1<<1, /* Clear host IRQ */ | ||
1620 | Y2_ASF_HOST_IRQ = 1<<0, /* Issue an IRQ to HOST system */ | ||
1621 | }; | ||
1622 | |||
1623 | /* STAT_CTRL 32 bit Status BMU control register (Yukon-2 only) */ | ||
1624 | enum { | ||
1625 | SC_STAT_CLR_IRQ = 1<<4, /* Status Burst IRQ clear */ | ||
1626 | SC_STAT_OP_ON = 1<<3, /* Operational Mode On */ | ||
1627 | SC_STAT_OP_OFF = 1<<2, /* Operational Mode Off */ | ||
1628 | SC_STAT_RST_CLR = 1<<1, /* Clear Status Unit Reset (Enable) */ | ||
1629 | SC_STAT_RST_SET = 1<<0, /* Set Status Unit Reset */ | ||
1630 | }; | ||
1631 | |||
1632 | /* GMAC_CTRL 32 bit GMAC Control Reg (YUKON only) */ | ||
1633 | enum { | ||
1634 | GMC_H_BURST_ON = 1<<7, /* Half Duplex Burst Mode On */ | ||
1635 | GMC_H_BURST_OFF = 1<<6, /* Half Duplex Burst Mode Off */ | ||
1636 | GMC_F_LOOPB_ON = 1<<5, /* FIFO Loopback On */ | ||
1637 | GMC_F_LOOPB_OFF = 1<<4, /* FIFO Loopback Off */ | ||
1638 | GMC_PAUSE_ON = 1<<3, /* Pause On */ | ||
1639 | GMC_PAUSE_OFF = 1<<2, /* Pause Off */ | ||
1640 | GMC_RST_CLR = 1<<1, /* Clear GMAC Reset */ | ||
1641 | GMC_RST_SET = 1<<0, /* Set GMAC Reset */ | ||
1642 | }; | ||
1643 | |||
1644 | /* GPHY_CTRL 32 bit GPHY Control Reg (YUKON only) */ | ||
1645 | enum { | ||
1646 | GPC_SEL_BDT = 1<<28, /* Select Bi-Dir. Transfer for MDC/MDIO */ | ||
1647 | GPC_INT_POL_HI = 1<<27, /* IRQ Polarity is Active HIGH */ | ||
1648 | GPC_75_OHM = 1<<26, /* Use 75 Ohm Termination instead of 50 */ | ||
1649 | GPC_DIS_FC = 1<<25, /* Disable Automatic Fiber/Copper Detection */ | ||
1650 | GPC_DIS_SLEEP = 1<<24, /* Disable Energy Detect */ | ||
1651 | GPC_HWCFG_M_3 = 1<<23, /* HWCFG_MODE[3] */ | ||
1652 | GPC_HWCFG_M_2 = 1<<22, /* HWCFG_MODE[2] */ | ||
1653 | GPC_HWCFG_M_1 = 1<<21, /* HWCFG_MODE[1] */ | ||
1654 | GPC_HWCFG_M_0 = 1<<20, /* HWCFG_MODE[0] */ | ||
1655 | GPC_ANEG_0 = 1<<19, /* ANEG[0] */ | ||
1656 | GPC_ENA_XC = 1<<18, /* Enable MDI crossover */ | ||
1657 | GPC_DIS_125 = 1<<17, /* Disable 125 MHz clock */ | ||
1658 | GPC_ANEG_3 = 1<<16, /* ANEG[3] */ | ||
1659 | GPC_ANEG_2 = 1<<15, /* ANEG[2] */ | ||
1660 | GPC_ANEG_1 = 1<<14, /* ANEG[1] */ | ||
1661 | GPC_ENA_PAUSE = 1<<13, /* Enable Pause (SYM_OR_REM) */ | ||
1662 | GPC_PHYADDR_4 = 1<<12, /* Bit 4 of Phy Addr */ | ||
1663 | GPC_PHYADDR_3 = 1<<11, /* Bit 3 of Phy Addr */ | ||
1664 | GPC_PHYADDR_2 = 1<<10, /* Bit 2 of Phy Addr */ | ||
1665 | GPC_PHYADDR_1 = 1<<9, /* Bit 1 of Phy Addr */ | ||
1666 | GPC_PHYADDR_0 = 1<<8, /* Bit 0 of Phy Addr */ | ||
1667 | /* Bits 7..2: reserved */ | ||
1668 | GPC_RST_CLR = 1<<1, /* Clear GPHY Reset */ | ||
1669 | GPC_RST_SET = 1<<0, /* Set GPHY Reset */ | ||
1670 | }; | ||
1671 | |||
1672 | /* GMAC_IRQ_SRC 8 bit GMAC Interrupt Source Reg (YUKON only) */ | ||
1673 | /* GMAC_IRQ_MSK 8 bit GMAC Interrupt Mask Reg (YUKON only) */ | ||
1674 | enum { | ||
1675 | GM_IS_TX_CO_OV = 1<<5, /* Transmit Counter Overflow IRQ */ | ||
1676 | GM_IS_RX_CO_OV = 1<<4, /* Receive Counter Overflow IRQ */ | ||
1677 | GM_IS_TX_FF_UR = 1<<3, /* Transmit FIFO Underrun */ | ||
1678 | GM_IS_TX_COMPL = 1<<2, /* Frame Transmission Complete */ | ||
1679 | GM_IS_RX_FF_OR = 1<<1, /* Receive FIFO Overrun */ | ||
1680 | GM_IS_RX_COMPL = 1<<0, /* Frame Reception Complete */ | ||
1681 | |||
1682 | #define GMAC_DEF_MSK (GM_IS_TX_CO_OV | GM_IS_RX_CO_OV |\ | ||
1683 | GM_IS_TX_FF_UR | GM_IS_RX_FF_OR) | ||
1684 | |||
1685 | /* GMAC_LINK_CTRL 16 bit GMAC Link Control Reg (YUKON only) */ | ||
1686 | /* Bits 15.. 2: reserved */ | ||
1687 | GMLC_RST_CLR = 1<<1, /* Clear GMAC Link Reset */ | ||
1688 | GMLC_RST_SET = 1<<0, /* Set GMAC Link Reset */ | ||
1689 | |||
1690 | |||
1691 | /* WOL_CTRL_STAT 16 bit WOL Control/Status Reg */ | ||
1692 | WOL_CTL_LINK_CHG_OCC = 1<<15, | ||
1693 | WOL_CTL_MAGIC_PKT_OCC = 1<<14, | ||
1694 | WOL_CTL_PATTERN_OCC = 1<<13, | ||
1695 | WOL_CTL_CLEAR_RESULT = 1<<12, | ||
1696 | WOL_CTL_ENA_PME_ON_LINK_CHG = 1<<11, | ||
1697 | WOL_CTL_DIS_PME_ON_LINK_CHG = 1<<10, | ||
1698 | WOL_CTL_ENA_PME_ON_MAGIC_PKT = 1<<9, | ||
1699 | WOL_CTL_DIS_PME_ON_MAGIC_PKT = 1<<8, | ||
1700 | WOL_CTL_ENA_PME_ON_PATTERN = 1<<7, | ||
1701 | WOL_CTL_DIS_PME_ON_PATTERN = 1<<6, | ||
1702 | WOL_CTL_ENA_LINK_CHG_UNIT = 1<<5, | ||
1703 | WOL_CTL_DIS_LINK_CHG_UNIT = 1<<4, | ||
1704 | WOL_CTL_ENA_MAGIC_PKT_UNIT = 1<<3, | ||
1705 | WOL_CTL_DIS_MAGIC_PKT_UNIT = 1<<2, | ||
1706 | WOL_CTL_ENA_PATTERN_UNIT = 1<<1, | ||
1707 | WOL_CTL_DIS_PATTERN_UNIT = 1<<0, | ||
1708 | }; | ||
1709 | |||
1710 | #define WOL_CTL_DEFAULT \ | ||
1711 | (WOL_CTL_DIS_PME_ON_LINK_CHG | \ | ||
1712 | WOL_CTL_DIS_PME_ON_PATTERN | \ | ||
1713 | WOL_CTL_DIS_PME_ON_MAGIC_PKT | \ | ||
1714 | WOL_CTL_DIS_LINK_CHG_UNIT | \ | ||
1715 | WOL_CTL_DIS_PATTERN_UNIT | \ | ||
1716 | WOL_CTL_DIS_MAGIC_PKT_UNIT) | ||
1717 | |||
1718 | /* WOL_MATCH_CTL 8 bit WOL Match Control Reg */ | ||
1719 | #define WOL_CTL_PATT_ENA(x) (1 << (x)) | ||
1720 | |||
1721 | |||
1722 | /* Control flags */ | ||
1723 | enum { | ||
1724 | UDPTCP = 1<<0, | ||
1725 | CALSUM = 1<<1, | ||
1726 | WR_SUM = 1<<2, | ||
1727 | INIT_SUM= 1<<3, | ||
1728 | LOCK_SUM= 1<<4, | ||
1729 | INS_VLAN= 1<<5, | ||
1730 | FRC_STAT= 1<<6, | ||
1731 | EOP = 1<<7, | ||
1732 | }; | ||
1733 | |||
1734 | enum { | ||
1735 | HW_OWNER = 1<<7, | ||
1736 | OP_TCPWRITE = 0x11, | ||
1737 | OP_TCPSTART = 0x12, | ||
1738 | OP_TCPINIT = 0x14, | ||
1739 | OP_TCPLCK = 0x18, | ||
1740 | OP_TCPCHKSUM = OP_TCPSTART, | ||
1741 | OP_TCPIS = OP_TCPINIT | OP_TCPSTART, | ||
1742 | OP_TCPLW = OP_TCPLCK | OP_TCPWRITE, | ||
1743 | OP_TCPLSW = OP_TCPLCK | OP_TCPSTART | OP_TCPWRITE, | ||
1744 | OP_TCPLISW = OP_TCPLCK | OP_TCPINIT | OP_TCPSTART | OP_TCPWRITE, | ||
1745 | |||
1746 | OP_ADDR64 = 0x21, | ||
1747 | OP_VLAN = 0x22, | ||
1748 | OP_ADDR64VLAN = OP_ADDR64 | OP_VLAN, | ||
1749 | OP_LRGLEN = 0x24, | ||
1750 | OP_LRGLENVLAN = OP_LRGLEN | OP_VLAN, | ||
1751 | OP_BUFFER = 0x40, | ||
1752 | OP_PACKET = 0x41, | ||
1753 | OP_LARGESEND = 0x43, | ||
1754 | |||
1755 | /* YUKON-2 STATUS opcodes defines */ | ||
1756 | OP_RXSTAT = 0x60, | ||
1757 | OP_RXTIMESTAMP = 0x61, | ||
1758 | OP_RXVLAN = 0x62, | ||
1759 | OP_RXCHKS = 0x64, | ||
1760 | OP_RXCHKSVLAN = OP_RXCHKS | OP_RXVLAN, | ||
1761 | OP_RXTIMEVLAN = OP_RXTIMESTAMP | OP_RXVLAN, | ||
1762 | OP_RSS_HASH = 0x65, | ||
1763 | OP_TXINDEXLE = 0x68, | ||
1764 | |||
1765 | /* YUKON-2 SPECIAL opcodes defines */ | ||
1766 | OP_PUTIDX = 0x70, | ||
1767 | }; | ||
1768 | |||
1769 | /* Yukon 2 hardware interface | ||
1770 | * Not tested on big endian | ||
1771 | */ | ||
1772 | struct sky2_tx_le { | ||
1773 | union { | ||
1774 | u32 addr; | ||
1775 | struct { | ||
1776 | u16 offset; | ||
1777 | u16 start; | ||
1778 | } csum; | ||
1779 | struct { | ||
1780 | u16 size; | ||
1781 | u16 rsvd; | ||
1782 | } tso; | ||
1783 | } tx; | ||
1784 | u16 length; /* also vlan tag or checksum start */ | ||
1785 | u8 ctrl; | ||
1786 | u8 opcode; | ||
1787 | }; | ||
1788 | |||
1789 | struct sky2_rx_le { | ||
1790 | union { | ||
1791 | u32 addr; | ||
1792 | struct { | ||
1793 | u16 start1; | ||
1794 | u16 start2; | ||
1795 | } csum; | ||
1796 | } rx; | ||
1797 | u16 length; | ||
1798 | u8 ctrl; | ||
1799 | u8 opcode; | ||
1800 | }; | ||
1801 | |||
1802 | struct sky2_status_le { | ||
1803 | u32 status; /* also checksum */ | ||
1804 | u16 length; /* also vlan tag */ | ||
1805 | u8 link; | ||
1806 | u8 opcode; | ||
1807 | }; | ||
1808 | |||
1809 | |||
1810 | struct ring_info { | ||
1811 | struct sk_buff *skb; | ||
1812 | DECLARE_PCI_UNMAP_ADDR(mapaddr); | ||
1813 | DECLARE_PCI_UNMAP_LEN(maplen); | ||
1814 | }; | ||
1815 | |||
1816 | struct sky2_port { | ||
1817 | struct sky2_hw *hw ____cacheline_aligned; | ||
1818 | struct net_device *netdev; | ||
1819 | unsigned port; | ||
1820 | u32 msg_enable; | ||
1821 | |||
1822 | struct ring_info *tx_ring ____cacheline_aligned; | ||
1823 | struct sky2_tx_le *tx_le; | ||
1824 | spinlock_t tx_lock; | ||
1825 | u16 tx_cons; /* next le to check */ | ||
1826 | u16 tx_prod; /* next le to use */ | ||
1827 | u16 tx_last_put; | ||
1828 | |||
1829 | struct ring_info *rx_ring ____cacheline_aligned; | ||
1830 | struct sky2_rx_le *rx_le; | ||
1831 | u16 rx_ring_size; | ||
1832 | u16 rx_next; /* next re to check */ | ||
1833 | u16 rx_put; /* next le index to use */ | ||
1834 | u16 rx_last_put; | ||
1835 | |||
1836 | dma_addr_t rx_le_map; | ||
1837 | dma_addr_t tx_le_map; | ||
1838 | u32 advertising; /* ADVERTISED_ bits */ | ||
1839 | u16 speed; /* SPEED_1000, SPEED_100, ... */ | ||
1840 | u8 autoneg; /* AUTONEG_ENABLE, AUTONEG_DISABLE */ | ||
1841 | u8 duplex; /* DUPLEX_HALF, DUPLEX_FULL */ | ||
1842 | u8 rx_pause; | ||
1843 | u8 tx_pause; | ||
1844 | u8 rx_csum; | ||
1845 | u8 wol; | ||
1846 | |||
1847 | struct tasklet_struct phy_task; | ||
1848 | struct net_device_stats net_stats; | ||
1849 | }; | ||
1850 | |||
1851 | struct sky2_hw { | ||
1852 | void __iomem *regs; | ||
1853 | struct pci_dev *pdev; | ||
1854 | u32 intr_mask; | ||
1855 | struct net_device *dev[2]; | ||
1856 | |||
1857 | u8 chip_id; | ||
1858 | u8 chip_rev; | ||
1859 | u8 copper; | ||
1860 | u8 ports; | ||
1861 | |||
1862 | struct sky2_status_le *st_le; | ||
1863 | u32 st_idx; | ||
1864 | dma_addr_t st_dma; | ||
1865 | |||
1866 | spinlock_t phy_lock; | ||
1867 | }; | ||
1868 | |||
1869 | /* Register accessor for memory mapped device */ | ||
1870 | static inline u32 sky2_read32(const struct sky2_hw *hw, unsigned reg) | ||
1871 | { | ||
1872 | return readl(hw->regs + reg); | ||
1873 | } | ||
1874 | |||
1875 | static inline u16 sky2_read16(const struct sky2_hw *hw, unsigned reg) | ||
1876 | { | ||
1877 | return readw(hw->regs + reg); | ||
1878 | } | ||
1879 | |||
1880 | static inline u8 sky2_read8(const struct sky2_hw *hw, unsigned reg) | ||
1881 | { | ||
1882 | return readb(hw->regs + reg); | ||
1883 | } | ||
1884 | |||
1885 | static inline int is_pciex(const struct sky2_hw *hw) | ||
1886 | { | ||
1887 | return (sky2_read32(hw, PCI_C(PCI_DEV_STATUS)) & PCI_OS_PCI_X) == 0; | ||
1888 | } | ||
1889 | |||
1890 | |||
1891 | static inline void sky2_write32(const struct sky2_hw *hw, unsigned reg, u32 val) | ||
1892 | { | ||
1893 | writel(val, hw->regs + reg); | ||
1894 | } | ||
1895 | |||
1896 | static inline void sky2_write16(const struct sky2_hw *hw, unsigned reg, u16 val) | ||
1897 | { | ||
1898 | writew(val, hw->regs + reg); | ||
1899 | } | ||
1900 | |||
1901 | static inline void sky2_write8(const struct sky2_hw *hw, unsigned reg, u8 val) | ||
1902 | { | ||
1903 | writeb(val, hw->regs + reg); | ||
1904 | } | ||
1905 | |||
1906 | /* Yukon PHY related registers */ | ||
1907 | #define SK_GMAC_REG(port,reg) \ | ||
1908 | (BASE_GMAC_1 + (port) * (BASE_GMAC_2-BASE_GMAC_1) + (reg)) | ||
1909 | #define GM_PHY_RETRIES 100 | ||
1910 | |||
1911 | static inline u16 gma_read16(const struct sky2_hw *hw, unsigned port, unsigned reg) | ||
1912 | { | ||
1913 | return sky2_read16(hw, SK_GMAC_REG(port,reg)); | ||
1914 | } | ||
1915 | |||
1916 | static inline u32 gma_read32(struct sky2_hw *hw, unsigned port, unsigned reg) | ||
1917 | { | ||
1918 | unsigned base = SK_GMAC_REG(port, reg); | ||
1919 | return (u32) sky2_read16(hw, base) | ||
1920 | | (u32) sky2_read16(hw, base+4) << 16; | ||
1921 | } | ||
1922 | |||
1923 | static inline void gma_write16(const struct sky2_hw *hw, unsigned port, int r, u16 v) | ||
1924 | { | ||
1925 | sky2_write16(hw, SK_GMAC_REG(port,r), v); | ||
1926 | } | ||
1927 | |||
1928 | static inline void gma_set_addr(struct sky2_hw *hw, unsigned port, unsigned reg, | ||
1929 | const u8 *addr) | ||
1930 | { | ||
1931 | gma_write16(hw, port, reg, (u16) addr[0] | ((u16) addr[1] << 8)); | ||
1932 | gma_write16(hw, port, reg+4,(u16) addr[2] | ((u16) addr[3] << 8)); | ||
1933 | gma_write16(hw, port, reg+8,(u16) addr[4] | ((u16) addr[5] << 8)); | ||
1934 | } | ||
1935 | #endif | ||