aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/net/Kconfig20
-rw-r--r--drivers/net/Makefile1
-rw-r--r--drivers/net/sky2.c2686
-rw-r--r--drivers/net/sky2.h1935
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
1937config 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
1947config 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
1936config SK98LIN 1954config 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
54obj-$(CONFIG_BNX2) += bnx2.o 54obj-$(CONFIG_BNX2) += bnx2.o
55obj-$(CONFIG_TC35815) += tc35815.o 55obj-$(CONFIG_TC35815) += tc35815.o
56obj-$(CONFIG_SKGE) += skge.o 56obj-$(CONFIG_SKGE) += skge.o
57obj-$(CONFIG_SKY2) += sky2.o
57obj-$(CONFIG_SK98LIN) += sk98lin/ 58obj-$(CONFIG_SK98LIN) += sk98lin/
58obj-$(CONFIG_SKFP) += skfp/ 59obj-$(CONFIG_SKFP) += skfp/
59obj-$(CONFIG_VIA_RHINE) += via-rhine.o 60obj-$(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
86static 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
91static int debug = -1; /* defaults above */
92module_param(debug, int, 0);
93MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
94
95static 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};
114MODULE_DEVICE_TABLE(pci, sky2_id_table);
115
116/* Avoid conditionals by using array */
117static const unsigned txqaddr[] = { Q_XA1, Q_XA2 };
118static const unsigned rxqaddr[] = { Q_R1, Q_R2 };
119
120static 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
142static 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
158static 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
178static 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
196static 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
396static 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
525static 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 */
558static 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 */
570static 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 */
589static 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
621static 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
628static 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 */
650static 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 */
671static 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
690static 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 */
709static 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;
736nomem:
737 sky2_rx_clean(sky2);
738 return -ENOMEM;
739}
740
741/* Bring up network interface. */
742static 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
814err_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
836static 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
842static 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. */
850static 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 */
993static 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 */
1045static inline void sky2_tx_clean(struct sky2_port *sky2)
1046{
1047 sky2_tx_complete(sky2->netdev, sky2->tx_prod);
1048}
1049
1050/* Network shutdown */
1051static 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
1145static 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
1160static 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
1198static 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 */
1238static 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
1307static 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
1320static 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 */
1343static 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
1375submit:
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
1388error:
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++;
1399reuse:
1400 re->skb = skb;
1401 skb = NULL;
1402 goto submit;
1403}
1404
1405static 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 */
1419static 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
1515static 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
1552static 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
1606static 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
1628static 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
1638static 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
1674static 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 */
1685static 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
1697static inline u32 sky2_ms2clk(const struct sky2_hw *hw, u32 ms)
1698{
1699 return sky2_khz(hw) * ms;
1700}
1701
1702static inline u32 sky2_us2clk(const struct sky2_hw *hw, u32 us)
1703{
1704 return (sky2_khz(hw) * 75) / 1000;
1705}
1706
1707static 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
1917static 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
1936static 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
1965static 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
2026static 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
2037static 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
2065static 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
2072static 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
2083static u32 sky2_get_msglevel(struct net_device *netdev)
2084{
2085 struct sky2_port *sky2 = netdev_priv(netdev);
2086 return sky2->msg_enable;
2087}
2088
2089static 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
2105static 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
2111static int sky2_get_stats_count(struct net_device *dev)
2112{
2113 return ARRAY_SIZE(sky2_stats);
2114}
2115
2116static 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
2124static 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 */
2141static 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
2159static 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
2179static 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 */
2225static 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 */
2249static 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
2287static 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
2297static 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
2316static 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
2324static 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
2348static 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 */
2376static __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
2443static 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
2454static 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, &reg);
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
2560err_out_free_netdev:
2561 free_netdev(dev);
2562
2563err_out_free_irq:
2564 free_irq(pdev->irq, hw);
2565err_out_free_pci:
2566 pci_free_consistent(hw->pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma);
2567err_out_iounmap:
2568 iounmap(hw->regs);
2569err_out_free_hw:
2570 kfree(hw);
2571err_out_free_regions:
2572 pci_release_regions(pdev);
2573err_out_disable_pdev:
2574 pci_disable_device(pdev);
2575 pci_set_drvdata(pdev, NULL);
2576err_out:
2577 return err;
2578}
2579
2580static 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
2609static 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
2636static 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
2659static 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
2670static int __init sky2_init_module(void)
2671{
2672
2673 return pci_module_init(&sky2_driver);
2674}
2675
2676static void __exit sky2_cleanup_module(void)
2677{
2678 pci_unregister_driver(&sky2_driver);
2679}
2680
2681module_init(sky2_init_module);
2682module_exit(sky2_cleanup_module);
2683
2684MODULE_DESCRIPTION("Marvell Yukon 2 Gigabit Ethernet driver");
2685MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
2686MODULE_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 */
18enum 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
27enum 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
47enum 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) */
63enum 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
79enum 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 */
217enum {
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 */
260enum {
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 */
292enum {
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 */
312enum {
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 */
345enum {
346 DPT_START = 1<<1,
347 DPT_STOP = 1<<0,
348};
349
350/* B2_TST_CTRL1 8 bit Test Control Register 1 */
351enum {
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 */
363enum {
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 */
371enum {
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) */
386enum {
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) */
398enum {
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) */
408enum {
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 */
421enum {
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 */
430enum {
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 */
442enum {
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 */
465enum {
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 */
480enum {
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
491enum {
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 */
504enum {
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)*/
539enum {
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 */
558enum {
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 */
577enum {
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 */
587enum {
588 PHY_ADDR_MARV = 0,
589};
590
591#define RB_ADDR(offs, queue) (B16_RAM_REGS + (queue) + (offs))
592
593
594enum {
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) */
634enum {
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 */
664enum {
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 */
672enum {
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 */
696enum {
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) */
707enum {
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 */
722enum {
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) */
731enum {
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) */
738enum {
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) */
747enum {
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)*/
761enum {
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
803enum {
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) */
813enum {
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
843enum {
844 WOL_PATT_RAM_1 = 0x1000,/* WOL Pattern RAM Link 1 */
845 WOL_PATT_RAM_2 = 0x1400,/* WOL Pattern RAM Link 2 */
846};
847
848enum {
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 */
856enum {
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
894enum {
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
907enum {
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
913enum {
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
925enum {
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 */
932enum {
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 */
947enum {
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 *****/
968enum {
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 */
980enum {
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) */
996enum {
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 */
1004enum {
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 *****/
1012enum {
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 *****/
1022enum {
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
1037enum {
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
1044enum {
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) */
1051enum {
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 *****/
1066enum {
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) */
1088enum {
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
1093enum {
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 *****/
1118enum {
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) */
1148enum {
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 */
1157enum {
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 *****/
1164enum {
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
1175enum {
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. *****/
1188enum {
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
1204enum {
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
1217enum {
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
1235enum {
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 *****/
1243enum {
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 *****/
1252enum {
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) */
1270enum {
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
1280enum {
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 *****/
1300enum {
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 *****/
1308enum {
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. *****/
1317enum {
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 */
1331enum {
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 */
1377enum {
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 */
1426enum {
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 */
1444enum {
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 */
1466enum {
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 */
1477enum {
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 */
1485enum {
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 */
1504enum {
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 */
1519enum {
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 */
1531enum {
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 */
1537enum {
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 */
1566enum {
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 */
1588enum {
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) */
1599enum {
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 */
1606enum {
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 */
1618enum {
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) */
1624enum {
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) */
1633enum {
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) */
1645enum {
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) */
1674enum {
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 */
1723enum {
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
1734enum {
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 */
1772struct 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
1789struct 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
1802struct sky2_status_le {
1803 u32 status; /* also checksum */
1804 u16 length; /* also vlan tag */
1805 u8 link;
1806 u8 opcode;
1807};
1808
1809
1810struct ring_info {
1811 struct sk_buff *skb;
1812 DECLARE_PCI_UNMAP_ADDR(mapaddr);
1813 DECLARE_PCI_UNMAP_LEN(maplen);
1814};
1815
1816struct 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
1851struct 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 */
1870static inline u32 sky2_read32(const struct sky2_hw *hw, unsigned reg)
1871{
1872 return readl(hw->regs + reg);
1873}
1874
1875static inline u16 sky2_read16(const struct sky2_hw *hw, unsigned reg)
1876{
1877 return readw(hw->regs + reg);
1878}
1879
1880static inline u8 sky2_read8(const struct sky2_hw *hw, unsigned reg)
1881{
1882 return readb(hw->regs + reg);
1883}
1884
1885static 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
1891static inline void sky2_write32(const struct sky2_hw *hw, unsigned reg, u32 val)
1892{
1893 writel(val, hw->regs + reg);
1894}
1895
1896static inline void sky2_write16(const struct sky2_hw *hw, unsigned reg, u16 val)
1897{
1898 writew(val, hw->regs + reg);
1899}
1900
1901static 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
1911static 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
1916static 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
1923static 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
1928static 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
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-25 10:25:08 -0500