f1c0ec308bfe6e35efe0ad121d6169b0938d4d91
[linux-2.6.git] / drivers / net / sky2.c
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.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27 #include <linux/crc32.h>
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/netdevice.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/etherdevice.h>
33 #include <linux/ethtool.h>
34 #include <linux/pci.h>
35 #include <linux/ip.h>
36 #include <net/ip.h>
37 #include <linux/tcp.h>
38 #include <linux/in.h>
39 #include <linux/delay.h>
40 #include <linux/workqueue.h>
41 #include <linux/if_vlan.h>
42 #include <linux/prefetch.h>
43 #include <linux/debugfs.h>
44 #include <linux/mii.h>
45
46 #include <asm/irq.h>
47
48 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
49 #define SKY2_VLAN_TAG_USED 1
50 #endif
51
52 #include "sky2.h"
53
54 #define DRV_NAME                "sky2"
55 #define DRV_VERSION             "1.27"
56
57 /*
58  * The Yukon II chipset takes 64 bit command blocks (called list elements)
59  * that are organized into three (receive, transmit, status) different rings
60  * similar to Tigon3.
61  */
62
63 #define RX_LE_SIZE              1024
64 #define RX_LE_BYTES             (RX_LE_SIZE*sizeof(struct sky2_rx_le))
65 #define RX_MAX_PENDING          (RX_LE_SIZE/6 - 2)
66 #define RX_DEF_PENDING          RX_MAX_PENDING
67
68 /* This is the worst case number of transmit list elements for a single skb:
69    VLAN:GSO + CKSUM + Data + skb_frags * DMA */
70 #define MAX_SKB_TX_LE   (2 + (sizeof(dma_addr_t)/sizeof(u32))*(MAX_SKB_FRAGS+1))
71 #define TX_MIN_PENDING          (MAX_SKB_TX_LE+1)
72 #define TX_MAX_PENDING          4096
73 #define TX_DEF_PENDING          127
74
75 #define STATUS_RING_SIZE        2048    /* 2 ports * (TX + 2*RX) */
76 #define STATUS_LE_BYTES         (STATUS_RING_SIZE*sizeof(struct sky2_status_le))
77 #define TX_WATCHDOG             (5 * HZ)
78 #define NAPI_WEIGHT             64
79 #define PHY_RETRIES             1000
80
81 #define SKY2_EEPROM_MAGIC       0x9955aabb
82
83
84 #define RING_NEXT(x,s)  (((x)+1) & ((s)-1))
85
86 static const u32 default_msg =
87     NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
88     | NETIF_MSG_TIMER | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR
89     | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
90
91 static int debug = -1;          /* defaults above */
92 module_param(debug, int, 0);
93 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
94
95 static int copybreak __read_mostly = 128;
96 module_param(copybreak, int, 0);
97 MODULE_PARM_DESC(copybreak, "Receive copy threshold");
98
99 static int disable_msi = 0;
100 module_param(disable_msi, int, 0);
101 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
102
103 static DEFINE_PCI_DEVICE_TABLE(sky2_id_table) = {
104         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) }, /* SK-9Sxx */
105         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) }, /* SK-9Exx */
106         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E01) }, /* SK-9E21M */
107         { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b00) },    /* DGE-560T */
108         { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4001) },    /* DGE-550SX */
109         { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4B02) },    /* DGE-560SX */
110         { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4B03) },    /* DGE-550T */
111         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4340) }, /* 88E8021 */
112         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4341) }, /* 88E8022 */
113         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4342) }, /* 88E8061 */
114         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4343) }, /* 88E8062 */
115         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4344) }, /* 88E8021 */
116         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4345) }, /* 88E8022 */
117         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4346) }, /* 88E8061 */
118         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4347) }, /* 88E8062 */
119         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4350) }, /* 88E8035 */
120         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4351) }, /* 88E8036 */
121         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4352) }, /* 88E8038 */
122         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4353) }, /* 88E8039 */
123         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4354) }, /* 88E8040 */
124         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4355) }, /* 88E8040T */
125         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4356) }, /* 88EC033 */
126         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4357) }, /* 88E8042 */
127         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x435A) }, /* 88E8048 */
128         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4360) }, /* 88E8052 */
129         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4361) }, /* 88E8050 */
130         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4362) }, /* 88E8053 */
131         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4363) }, /* 88E8055 */
132         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4364) }, /* 88E8056 */
133         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4365) }, /* 88E8070 */
134         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4366) }, /* 88EC036 */
135         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4367) }, /* 88EC032 */
136         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4368) }, /* 88EC034 */
137         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4369) }, /* 88EC042 */
138         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x436A) }, /* 88E8058 */
139         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x436B) }, /* 88E8071 */
140         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x436C) }, /* 88E8072 */
141         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x436D) }, /* 88E8055 */
142         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4370) }, /* 88E8075 */
143         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4380) }, /* 88E8057 */
144         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4381) }, /* 88E8059 */
145         { 0 }
146 };
147
148 MODULE_DEVICE_TABLE(pci, sky2_id_table);
149
150 /* Avoid conditionals by using array */
151 static const unsigned txqaddr[] = { Q_XA1, Q_XA2 };
152 static const unsigned rxqaddr[] = { Q_R1, Q_R2 };
153 static const u32 portirq_msk[] = { Y2_IS_PORT_1, Y2_IS_PORT_2 };
154
155 static void sky2_set_multicast(struct net_device *dev);
156
157 /* Access to PHY via serial interconnect */
158 static int gm_phy_write(struct sky2_hw *hw, unsigned port, u16 reg, u16 val)
159 {
160         int i;
161
162         gma_write16(hw, port, GM_SMI_DATA, val);
163         gma_write16(hw, port, GM_SMI_CTRL,
164                     GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) | GM_SMI_CT_REG_AD(reg));
165
166         for (i = 0; i < PHY_RETRIES; i++) {
167                 u16 ctrl = gma_read16(hw, port, GM_SMI_CTRL);
168                 if (ctrl == 0xffff)
169                         goto io_error;
170
171                 if (!(ctrl & GM_SMI_CT_BUSY))
172                         return 0;
173
174                 udelay(10);
175         }
176
177         dev_warn(&hw->pdev->dev,"%s: phy write timeout\n", hw->dev[port]->name);
178         return -ETIMEDOUT;
179
180 io_error:
181         dev_err(&hw->pdev->dev, "%s: phy I/O error\n", hw->dev[port]->name);
182         return -EIO;
183 }
184
185 static int __gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg, u16 *val)
186 {
187         int i;
188
189         gma_write16(hw, port, GM_SMI_CTRL, GM_SMI_CT_PHY_AD(PHY_ADDR_MARV)
190                     | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD);
191
192         for (i = 0; i < PHY_RETRIES; i++) {
193                 u16 ctrl = gma_read16(hw, port, GM_SMI_CTRL);
194                 if (ctrl == 0xffff)
195                         goto io_error;
196
197                 if (ctrl & GM_SMI_CT_RD_VAL) {
198                         *val = gma_read16(hw, port, GM_SMI_DATA);
199                         return 0;
200                 }
201
202                 udelay(10);
203         }
204
205         dev_warn(&hw->pdev->dev, "%s: phy read timeout\n", hw->dev[port]->name);
206         return -ETIMEDOUT;
207 io_error:
208         dev_err(&hw->pdev->dev, "%s: phy I/O error\n", hw->dev[port]->name);
209         return -EIO;
210 }
211
212 static inline u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg)
213 {
214         u16 v;
215         __gm_phy_read(hw, port, reg, &v);
216         return v;
217 }
218
219
220 static void sky2_power_on(struct sky2_hw *hw)
221 {
222         /* switch power to VCC (WA for VAUX problem) */
223         sky2_write8(hw, B0_POWER_CTRL,
224                     PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON);
225
226         /* disable Core Clock Division, */
227         sky2_write32(hw, B2_Y2_CLK_CTRL, Y2_CLK_DIV_DIS);
228
229         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > CHIP_REV_YU_XL_A1)
230                 /* enable bits are inverted */
231                 sky2_write8(hw, B2_Y2_CLK_GATE,
232                             Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
233                             Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
234                             Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS);
235         else
236                 sky2_write8(hw, B2_Y2_CLK_GATE, 0);
237
238         if (hw->flags & SKY2_HW_ADV_POWER_CTL) {
239                 u32 reg;
240
241                 sky2_pci_write32(hw, PCI_DEV_REG3, 0);
242
243                 reg = sky2_pci_read32(hw, PCI_DEV_REG4);
244                 /* set all bits to 0 except bits 15..12 and 8 */
245                 reg &= P_ASPM_CONTROL_MSK;
246                 sky2_pci_write32(hw, PCI_DEV_REG4, reg);
247
248                 reg = sky2_pci_read32(hw, PCI_DEV_REG5);
249                 /* set all bits to 0 except bits 28 & 27 */
250                 reg &= P_CTL_TIM_VMAIN_AV_MSK;
251                 sky2_pci_write32(hw, PCI_DEV_REG5, reg);
252
253                 sky2_pci_write32(hw, PCI_CFG_REG_1, 0);
254
255                 sky2_write16(hw, B0_CTST, Y2_HW_WOL_ON);
256
257                 /* Enable workaround for dev 4.107 on Yukon-Ultra & Extreme */
258                 reg = sky2_read32(hw, B2_GP_IO);
259                 reg |= GLB_GPIO_STAT_RACE_DIS;
260                 sky2_write32(hw, B2_GP_IO, reg);
261
262                 sky2_read32(hw, B2_GP_IO);
263         }
264
265         /* Turn on "driver loaded" LED */
266         sky2_write16(hw, B0_CTST, Y2_LED_STAT_ON);
267 }
268
269 static void sky2_power_aux(struct sky2_hw *hw)
270 {
271         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > CHIP_REV_YU_XL_A1)
272                 sky2_write8(hw, B2_Y2_CLK_GATE, 0);
273         else
274                 /* enable bits are inverted */
275                 sky2_write8(hw, B2_Y2_CLK_GATE,
276                             Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
277                             Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
278                             Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS);
279
280         /* switch power to VAUX if supported and PME from D3cold */
281         if ( (sky2_read32(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
282              pci_pme_capable(hw->pdev, PCI_D3cold))
283                 sky2_write8(hw, B0_POWER_CTRL,
284                             (PC_VAUX_ENA | PC_VCC_ENA |
285                              PC_VAUX_ON | PC_VCC_OFF));
286
287         /* turn off "driver loaded LED" */
288         sky2_write16(hw, B0_CTST, Y2_LED_STAT_OFF);
289 }
290
291 static void sky2_gmac_reset(struct sky2_hw *hw, unsigned port)
292 {
293         u16 reg;
294
295         /* disable all GMAC IRQ's */
296         sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0);
297
298         gma_write16(hw, port, GM_MC_ADDR_H1, 0);        /* clear MC hash */
299         gma_write16(hw, port, GM_MC_ADDR_H2, 0);
300         gma_write16(hw, port, GM_MC_ADDR_H3, 0);
301         gma_write16(hw, port, GM_MC_ADDR_H4, 0);
302
303         reg = gma_read16(hw, port, GM_RX_CTRL);
304         reg |= GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA;
305         gma_write16(hw, port, GM_RX_CTRL, reg);
306 }
307
308 /* flow control to advertise bits */
309 static const u16 copper_fc_adv[] = {
310         [FC_NONE]       = 0,
311         [FC_TX]         = PHY_M_AN_ASP,
312         [FC_RX]         = PHY_M_AN_PC,
313         [FC_BOTH]       = PHY_M_AN_PC | PHY_M_AN_ASP,
314 };
315
316 /* flow control to advertise bits when using 1000BaseX */
317 static const u16 fiber_fc_adv[] = {
318         [FC_NONE] = PHY_M_P_NO_PAUSE_X,
319         [FC_TX]   = PHY_M_P_ASYM_MD_X,
320         [FC_RX]   = PHY_M_P_SYM_MD_X,
321         [FC_BOTH] = PHY_M_P_BOTH_MD_X,
322 };
323
324 /* flow control to GMA disable bits */
325 static const u16 gm_fc_disable[] = {
326         [FC_NONE] = GM_GPCR_FC_RX_DIS | GM_GPCR_FC_TX_DIS,
327         [FC_TX]   = GM_GPCR_FC_RX_DIS,
328         [FC_RX]   = GM_GPCR_FC_TX_DIS,
329         [FC_BOTH] = 0,
330 };
331
332
333 static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
334 {
335         struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
336         u16 ctrl, ct1000, adv, pg, ledctrl, ledover, reg;
337
338         if ( (sky2->flags & SKY2_FLAG_AUTO_SPEED) &&
339             !(hw->flags & SKY2_HW_NEWER_PHY)) {
340                 u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL);
341
342                 ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK |
343                            PHY_M_EC_MAC_S_MSK);
344                 ectrl |= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ);
345
346                 /* on PHY 88E1040 Rev.D0 (and newer) downshift control changed */
347                 if (hw->chip_id == CHIP_ID_YUKON_EC)
348                         /* set downshift counter to 3x and enable downshift */
349                         ectrl |= PHY_M_EC_DSC_2(2) | PHY_M_EC_DOWN_S_ENA;
350                 else
351                         /* set master & slave downshift counter to 1x */
352                         ectrl |= PHY_M_EC_M_DSC(0) | PHY_M_EC_S_DSC(1);
353
354                 gm_phy_write(hw, port, PHY_MARV_EXT_CTRL, ectrl);
355         }
356
357         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
358         if (sky2_is_copper(hw)) {
359                 if (!(hw->flags & SKY2_HW_GIGABIT)) {
360                         /* enable automatic crossover */
361                         ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO) >> 1;
362
363                         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
364                             hw->chip_rev == CHIP_REV_YU_FE2_A0) {
365                                 u16 spec;
366
367                                 /* Enable Class A driver for FE+ A0 */
368                                 spec = gm_phy_read(hw, port, PHY_MARV_FE_SPEC_2);
369                                 spec |= PHY_M_FESC_SEL_CL_A;
370                                 gm_phy_write(hw, port, PHY_MARV_FE_SPEC_2, spec);
371                         }
372                 } else {
373                         /* disable energy detect */
374                         ctrl &= ~PHY_M_PC_EN_DET_MSK;
375
376                         /* enable automatic crossover */
377                         ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO);
378
379                         /* downshift on PHY 88E1112 and 88E1149 is changed */
380                         if ( (sky2->flags & SKY2_FLAG_AUTO_SPEED) &&
381                              (hw->flags & SKY2_HW_NEWER_PHY)) {
382                                 /* set downshift counter to 3x and enable downshift */
383                                 ctrl &= ~PHY_M_PC_DSC_MSK;
384                                 ctrl |= PHY_M_PC_DSC(2) | PHY_M_PC_DOWN_S_ENA;
385                         }
386                 }
387         } else {
388                 /* workaround for deviation #4.88 (CRC errors) */
389                 /* disable Automatic Crossover */
390
391                 ctrl &= ~PHY_M_PC_MDIX_MSK;
392         }
393
394         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
395
396         /* special setup for PHY 88E1112 Fiber */
397         if (hw->chip_id == CHIP_ID_YUKON_XL && (hw->flags & SKY2_HW_FIBRE_PHY)) {
398                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
399
400                 /* Fiber: select 1000BASE-X only mode MAC Specific Ctrl Reg. */
401                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
402                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
403                 ctrl &= ~PHY_M_MAC_MD_MSK;
404                 ctrl |= PHY_M_MAC_MODE_SEL(PHY_M_MAC_MD_1000BX);
405                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
406
407                 if (hw->pmd_type  == 'P') {
408                         /* select page 1 to access Fiber registers */
409                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 1);
410
411                         /* for SFP-module set SIGDET polarity to low */
412                         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
413                         ctrl |= PHY_M_FIB_SIGD_POL;
414                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
415                 }
416
417                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
418         }
419
420         ctrl = PHY_CT_RESET;
421         ct1000 = 0;
422         adv = PHY_AN_CSMA;
423         reg = 0;
424
425         if (sky2->flags & SKY2_FLAG_AUTO_SPEED) {
426                 if (sky2_is_copper(hw)) {
427                         if (sky2->advertising & ADVERTISED_1000baseT_Full)
428                                 ct1000 |= PHY_M_1000C_AFD;
429                         if (sky2->advertising & ADVERTISED_1000baseT_Half)
430                                 ct1000 |= PHY_M_1000C_AHD;
431                         if (sky2->advertising & ADVERTISED_100baseT_Full)
432                                 adv |= PHY_M_AN_100_FD;
433                         if (sky2->advertising & ADVERTISED_100baseT_Half)
434                                 adv |= PHY_M_AN_100_HD;
435                         if (sky2->advertising & ADVERTISED_10baseT_Full)
436                                 adv |= PHY_M_AN_10_FD;
437                         if (sky2->advertising & ADVERTISED_10baseT_Half)
438                                 adv |= PHY_M_AN_10_HD;
439
440                 } else {        /* special defines for FIBER (88E1040S only) */
441                         if (sky2->advertising & ADVERTISED_1000baseT_Full)
442                                 adv |= PHY_M_AN_1000X_AFD;
443                         if (sky2->advertising & ADVERTISED_1000baseT_Half)
444                                 adv |= PHY_M_AN_1000X_AHD;
445                 }
446
447                 /* Restart Auto-negotiation */
448                 ctrl |= PHY_CT_ANE | PHY_CT_RE_CFG;
449         } else {
450                 /* forced speed/duplex settings */
451                 ct1000 = PHY_M_1000C_MSE;
452
453                 /* Disable auto update for duplex flow control and duplex */
454                 reg |= GM_GPCR_AU_DUP_DIS | GM_GPCR_AU_SPD_DIS;
455
456                 switch (sky2->speed) {
457                 case SPEED_1000:
458                         ctrl |= PHY_CT_SP1000;
459                         reg |= GM_GPCR_SPEED_1000;
460                         break;
461                 case SPEED_100:
462                         ctrl |= PHY_CT_SP100;
463                         reg |= GM_GPCR_SPEED_100;
464                         break;
465                 }
466
467                 if (sky2->duplex == DUPLEX_FULL) {
468                         reg |= GM_GPCR_DUP_FULL;
469                         ctrl |= PHY_CT_DUP_MD;
470                 } else if (sky2->speed < SPEED_1000)
471                         sky2->flow_mode = FC_NONE;
472         }
473
474         if (sky2->flags & SKY2_FLAG_AUTO_PAUSE) {
475                 if (sky2_is_copper(hw))
476                         adv |= copper_fc_adv[sky2->flow_mode];
477                 else
478                         adv |= fiber_fc_adv[sky2->flow_mode];
479         } else {
480                 reg |= GM_GPCR_AU_FCT_DIS;
481                 reg |= gm_fc_disable[sky2->flow_mode];
482
483                 /* Forward pause packets to GMAC? */
484                 if (sky2->flow_mode & FC_RX)
485                         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON);
486                 else
487                         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
488         }
489
490         gma_write16(hw, port, GM_GP_CTRL, reg);
491
492         if (hw->flags & SKY2_HW_GIGABIT)
493                 gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, ct1000);
494
495         gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, adv);
496         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
497
498         /* Setup Phy LED's */
499         ledctrl = PHY_M_LED_PULS_DUR(PULS_170MS);
500         ledover = 0;
501
502         switch (hw->chip_id) {
503         case CHIP_ID_YUKON_FE:
504                 /* on 88E3082 these bits are at 11..9 (shifted left) */
505                 ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) << 1;
506
507                 ctrl = gm_phy_read(hw, port, PHY_MARV_FE_LED_PAR);
508
509                 /* delete ACT LED control bits */
510                 ctrl &= ~PHY_M_FELP_LED1_MSK;
511                 /* change ACT LED control to blink mode */
512                 ctrl |= PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_ACT_BL);
513                 gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl);
514                 break;
515
516         case CHIP_ID_YUKON_FE_P:
517                 /* Enable Link Partner Next Page */
518                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
519                 ctrl |= PHY_M_PC_ENA_LIP_NP;
520
521                 /* disable Energy Detect and enable scrambler */
522                 ctrl &= ~(PHY_M_PC_ENA_ENE_DT | PHY_M_PC_DIS_SCRAMB);
523                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
524
525                 /* set LED2 -> ACT, LED1 -> LINK, LED0 -> SPEED */
526                 ctrl = PHY_M_FELP_LED2_CTRL(LED_PAR_CTRL_ACT_BL) |
527                         PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_LINK) |
528                         PHY_M_FELP_LED0_CTRL(LED_PAR_CTRL_SPEED);
529
530                 gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl);
531                 break;
532
533         case CHIP_ID_YUKON_XL:
534                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
535
536                 /* select page 3 to access LED control register */
537                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
538
539                 /* set LED Function Control register */
540                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
541                              (PHY_M_LEDC_LOS_CTRL(1) |  /* LINK/ACT */
542                               PHY_M_LEDC_INIT_CTRL(7) | /* 10 Mbps */
543                               PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
544                               PHY_M_LEDC_STA0_CTRL(7)));        /* 1000 Mbps */
545
546                 /* set Polarity Control register */
547                 gm_phy_write(hw, port, PHY_MARV_PHY_STAT,
548                              (PHY_M_POLC_LS1_P_MIX(4) |
549                               PHY_M_POLC_IS0_P_MIX(4) |
550                               PHY_M_POLC_LOS_CTRL(2) |
551                               PHY_M_POLC_INIT_CTRL(2) |
552                               PHY_M_POLC_STA1_CTRL(2) |
553                               PHY_M_POLC_STA0_CTRL(2)));
554
555                 /* restore page register */
556                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
557                 break;
558
559         case CHIP_ID_YUKON_EC_U:
560         case CHIP_ID_YUKON_EX:
561         case CHIP_ID_YUKON_SUPR:
562                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
563
564                 /* select page 3 to access LED control register */
565                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
566
567                 /* set LED Function Control register */
568                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
569                              (PHY_M_LEDC_LOS_CTRL(1) |  /* LINK/ACT */
570                               PHY_M_LEDC_INIT_CTRL(8) | /* 10 Mbps */
571                               PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
572                               PHY_M_LEDC_STA0_CTRL(7)));/* 1000 Mbps */
573
574                 /* set Blink Rate in LED Timer Control Register */
575                 gm_phy_write(hw, port, PHY_MARV_INT_MASK,
576                              ledctrl | PHY_M_LED_BLINK_RT(BLINK_84MS));
577                 /* restore page register */
578                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
579                 break;
580
581         default:
582                 /* set Tx LED (LED_TX) to blink mode on Rx OR Tx activity */
583                 ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) | PHY_M_LEDC_TX_CTRL;
584
585                 /* turn off the Rx LED (LED_RX) */
586                 ledover |= PHY_M_LED_MO_RX(MO_LED_OFF);
587         }
588
589         if (hw->chip_id == CHIP_ID_YUKON_EC_U || hw->chip_id == CHIP_ID_YUKON_UL_2) {
590                 /* apply fixes in PHY AFE */
591                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 255);
592
593                 /* increase differential signal amplitude in 10BASE-T */
594                 gm_phy_write(hw, port, 0x18, 0xaa99);
595                 gm_phy_write(hw, port, 0x17, 0x2011);
596
597                 if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
598                         /* fix for IEEE A/B Symmetry failure in 1000BASE-T */
599                         gm_phy_write(hw, port, 0x18, 0xa204);
600                         gm_phy_write(hw, port, 0x17, 0x2002);
601                 }
602
603                 /* set page register to 0 */
604                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
605         } else if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
606                    hw->chip_rev == CHIP_REV_YU_FE2_A0) {
607                 /* apply workaround for integrated resistors calibration */
608                 gm_phy_write(hw, port, PHY_MARV_PAGE_ADDR, 17);
609                 gm_phy_write(hw, port, PHY_MARV_PAGE_DATA, 0x3f60);
610         } else if (hw->chip_id == CHIP_ID_YUKON_OPT && hw->chip_rev == 0) {
611                 /* apply fixes in PHY AFE */
612                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0x00ff);
613
614                 /* apply RDAC termination workaround */
615                 gm_phy_write(hw, port, 24, 0x2800);
616                 gm_phy_write(hw, port, 23, 0x2001);
617
618                 /* set page register back to 0 */
619                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
620         } else if (hw->chip_id != CHIP_ID_YUKON_EX &&
621                    hw->chip_id < CHIP_ID_YUKON_SUPR) {
622                 /* no effect on Yukon-XL */
623                 gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
624
625                 if (!(sky2->flags & SKY2_FLAG_AUTO_SPEED) ||
626                     sky2->speed == SPEED_100) {
627                         /* turn on 100 Mbps LED (LED_LINK100) */
628                         ledover |= PHY_M_LED_MO_100(MO_LED_ON);
629                 }
630
631                 if (ledover)
632                         gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover);
633
634         }
635
636         /* Enable phy interrupt on auto-negotiation complete (or link up) */
637         if (sky2->flags & SKY2_FLAG_AUTO_SPEED)
638                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_COMPL);
639         else
640                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK);
641 }
642
643 static const u32 phy_power[] = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
644 static const u32 coma_mode[] = { PCI_Y2_PHY1_COMA, PCI_Y2_PHY2_COMA };
645
646 static void sky2_phy_power_up(struct sky2_hw *hw, unsigned port)
647 {
648         u32 reg1;
649
650         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
651         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
652         reg1 &= ~phy_power[port];
653
654         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > CHIP_REV_YU_XL_A1)
655                 reg1 |= coma_mode[port];
656
657         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
658         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
659         sky2_pci_read32(hw, PCI_DEV_REG1);
660
661         if (hw->chip_id == CHIP_ID_YUKON_FE)
662                 gm_phy_write(hw, port, PHY_MARV_CTRL, PHY_CT_ANE);
663         else if (hw->flags & SKY2_HW_ADV_POWER_CTL)
664                 sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
665 }
666
667 static void sky2_phy_power_down(struct sky2_hw *hw, unsigned port)
668 {
669         u32 reg1;
670         u16 ctrl;
671
672         /* release GPHY Control reset */
673         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
674
675         /* release GMAC reset */
676         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR);
677
678         if (hw->flags & SKY2_HW_NEWER_PHY) {
679                 /* select page 2 to access MAC control register */
680                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
681
682                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
683                 /* allow GMII Power Down */
684                 ctrl &= ~PHY_M_MAC_GMIF_PUP;
685                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
686
687                 /* set page register back to 0 */
688                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
689         }
690
691         /* setup General Purpose Control Register */
692         gma_write16(hw, port, GM_GP_CTRL,
693                     GM_GPCR_FL_PASS | GM_GPCR_SPEED_100 |
694                     GM_GPCR_AU_DUP_DIS | GM_GPCR_AU_FCT_DIS |
695                     GM_GPCR_AU_SPD_DIS);
696
697         if (hw->chip_id != CHIP_ID_YUKON_EC) {
698                 if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
699                         /* select page 2 to access MAC control register */
700                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
701
702                         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
703                         /* enable Power Down */
704                         ctrl |= PHY_M_PC_POW_D_ENA;
705                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
706
707                         /* set page register back to 0 */
708                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
709                 }
710
711                 /* set IEEE compatible Power Down Mode (dev. #4.99) */
712                 gm_phy_write(hw, port, PHY_MARV_CTRL, PHY_CT_PDOWN);
713         }
714
715         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
716         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
717         reg1 |= phy_power[port];                /* set PHY to PowerDown/COMA Mode */
718         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
719         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
720 }
721
722 /* Force a renegotiation */
723 static void sky2_phy_reinit(struct sky2_port *sky2)
724 {
725         spin_lock_bh(&sky2->phy_lock);
726         sky2_phy_init(sky2->hw, sky2->port);
727         spin_unlock_bh(&sky2->phy_lock);
728 }
729
730 /* Put device in state to listen for Wake On Lan */
731 static void sky2_wol_init(struct sky2_port *sky2)
732 {
733         struct sky2_hw *hw = sky2->hw;
734         unsigned port = sky2->port;
735         enum flow_control save_mode;
736         u16 ctrl;
737
738         /* Bring hardware out of reset */
739         sky2_write16(hw, B0_CTST, CS_RST_CLR);
740         sky2_write16(hw, SK_REG(port, GMAC_LINK_CTRL), GMLC_RST_CLR);
741
742         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
743         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR);
744
745         /* Force to 10/100
746          * sky2_reset will re-enable on resume
747          */
748         save_mode = sky2->flow_mode;
749         ctrl = sky2->advertising;
750
751         sky2->advertising &= ~(ADVERTISED_1000baseT_Half|ADVERTISED_1000baseT_Full);
752         sky2->flow_mode = FC_NONE;
753
754         spin_lock_bh(&sky2->phy_lock);
755         sky2_phy_power_up(hw, port);
756         sky2_phy_init(hw, port);
757         spin_unlock_bh(&sky2->phy_lock);
758
759         sky2->flow_mode = save_mode;
760         sky2->advertising = ctrl;
761
762         /* Set GMAC to no flow control and auto update for speed/duplex */
763         gma_write16(hw, port, GM_GP_CTRL,
764                     GM_GPCR_FC_TX_DIS|GM_GPCR_TX_ENA|GM_GPCR_RX_ENA|
765                     GM_GPCR_DUP_FULL|GM_GPCR_FC_RX_DIS|GM_GPCR_AU_FCT_DIS);
766
767         /* Set WOL address */
768         memcpy_toio(hw->regs + WOL_REGS(port, WOL_MAC_ADDR),
769                     sky2->netdev->dev_addr, ETH_ALEN);
770
771         /* Turn on appropriate WOL control bits */
772         sky2_write16(hw, WOL_REGS(port, WOL_CTRL_STAT), WOL_CTL_CLEAR_RESULT);
773         ctrl = 0;
774         if (sky2->wol & WAKE_PHY)
775                 ctrl |= WOL_CTL_ENA_PME_ON_LINK_CHG|WOL_CTL_ENA_LINK_CHG_UNIT;
776         else
777                 ctrl |= WOL_CTL_DIS_PME_ON_LINK_CHG|WOL_CTL_DIS_LINK_CHG_UNIT;
778
779         if (sky2->wol & WAKE_MAGIC)
780                 ctrl |= WOL_CTL_ENA_PME_ON_MAGIC_PKT|WOL_CTL_ENA_MAGIC_PKT_UNIT;
781         else
782                 ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;
783
784         ctrl |= WOL_CTL_DIS_PME_ON_PATTERN|WOL_CTL_DIS_PATTERN_UNIT;
785         sky2_write16(hw, WOL_REGS(port, WOL_CTRL_STAT), ctrl);
786
787         /* Disable PiG firmware */
788         sky2_write16(hw, B0_CTST, Y2_HW_WOL_OFF);
789
790         /* block receiver */
791         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET);
792 }
793
794 static void sky2_set_tx_stfwd(struct sky2_hw *hw, unsigned port)
795 {
796         struct net_device *dev = hw->dev[port];
797
798         if ( (hw->chip_id == CHIP_ID_YUKON_EX &&
799               hw->chip_rev != CHIP_REV_YU_EX_A0) ||
800              hw->chip_id >= CHIP_ID_YUKON_FE_P) {
801                 /* Yukon-Extreme B0 and further Extreme devices */
802                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_STFW_ENA);
803         } else if (dev->mtu > ETH_DATA_LEN) {
804                 /* set Tx GMAC FIFO Almost Empty Threshold */
805                 sky2_write32(hw, SK_REG(port, TX_GMF_AE_THR),
806                              (ECU_JUMBO_WM << 16) | ECU_AE_THR);
807
808                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_STFW_DIS);
809         } else
810                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_STFW_ENA);
811 }
812
813 static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
814 {
815         struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
816         u16 reg;
817         u32 rx_reg;
818         int i;
819         const u8 *addr = hw->dev[port]->dev_addr;
820
821         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
822         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
823
824         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR);
825
826         if (hw->chip_id == CHIP_ID_YUKON_XL &&
827             hw->chip_rev == CHIP_REV_YU_XL_A0 &&
828             port == 1) {
829                 /* WA DEV_472 -- looks like crossed wires on port 2 */
830                 /* clear GMAC 1 Control reset */
831                 sky2_write8(hw, SK_REG(0, GMAC_CTRL), GMC_RST_CLR);
832                 do {
833                         sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_SET);
834                         sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_CLR);
835                 } while (gm_phy_read(hw, 1, PHY_MARV_ID0) != PHY_MARV_ID0_VAL ||
836                          gm_phy_read(hw, 1, PHY_MARV_ID1) != PHY_MARV_ID1_Y2 ||
837                          gm_phy_read(hw, 1, PHY_MARV_INT_MASK) != 0);
838         }
839
840         sky2_read16(hw, SK_REG(port, GMAC_IRQ_SRC));
841
842         /* Enable Transmit FIFO Underrun */
843         sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), GMAC_DEF_MSK);
844
845         spin_lock_bh(&sky2->phy_lock);
846         sky2_phy_power_up(hw, port);
847         sky2_phy_init(hw, port);
848         spin_unlock_bh(&sky2->phy_lock);
849
850         /* MIB clear */
851         reg = gma_read16(hw, port, GM_PHY_ADDR);
852         gma_write16(hw, port, GM_PHY_ADDR, reg | GM_PAR_MIB_CLR);
853
854         for (i = GM_MIB_CNT_BASE; i <= GM_MIB_CNT_END; i += 4)
855                 gma_read16(hw, port, i);
856         gma_write16(hw, port, GM_PHY_ADDR, reg);
857
858         /* transmit control */
859         gma_write16(hw, port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF));
860
861         /* receive control reg: unicast + multicast + no FCS  */
862         gma_write16(hw, port, GM_RX_CTRL,
863                     GM_RXCR_UCF_ENA | GM_RXCR_CRC_DIS | GM_RXCR_MCF_ENA);
864
865         /* transmit flow control */
866         gma_write16(hw, port, GM_TX_FLOW_CTRL, 0xffff);
867
868         /* transmit parameter */
869         gma_write16(hw, port, GM_TX_PARAM,
870                     TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) |
871                     TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) |
872                     TX_IPG_JAM_DATA(TX_IPG_JAM_DEF) |
873                     TX_BACK_OFF_LIM(TX_BOF_LIM_DEF));
874
875         /* serial mode register */
876         reg = DATA_BLIND_VAL(DATA_BLIND_DEF) |
877                 GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
878
879         if (hw->dev[port]->mtu > ETH_DATA_LEN)
880                 reg |= GM_SMOD_JUMBO_ENA;
881
882         if (hw->chip_id == CHIP_ID_YUKON_EC_U &&
883             hw->chip_rev == CHIP_REV_YU_EC_U_B1)
884                 reg |= GM_NEW_FLOW_CTRL;
885
886         gma_write16(hw, port, GM_SERIAL_MODE, reg);
887
888         /* virtual address for data */
889         gma_set_addr(hw, port, GM_SRC_ADDR_2L, addr);
890
891         /* physical address: used for pause frames */
892         gma_set_addr(hw, port, GM_SRC_ADDR_1L, addr);
893
894         /* ignore counter overflows */
895         gma_write16(hw, port, GM_TX_IRQ_MSK, 0);
896         gma_write16(hw, port, GM_RX_IRQ_MSK, 0);
897         gma_write16(hw, port, GM_TR_IRQ_MSK, 0);
898
899         /* Configure Rx MAC FIFO */
900         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR);
901         rx_reg = GMF_OPER_ON | GMF_RX_F_FL_ON;
902         if (hw->chip_id == CHIP_ID_YUKON_EX ||
903             hw->chip_id == CHIP_ID_YUKON_FE_P)
904                 rx_reg |= GMF_RX_OVER_ON;
905
906         sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), rx_reg);
907
908         if (hw->chip_id == CHIP_ID_YUKON_XL) {
909                 /* Hardware errata - clear flush mask */
910                 sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), 0);
911         } else {
912                 /* Flush Rx MAC FIFO on any flow control or error */
913                 sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR);
914         }
915
916         /* Set threshold to 0xa (64 bytes) + 1 to workaround pause bug  */
917         reg = RX_GMF_FL_THR_DEF + 1;
918         /* Another magic mystery workaround from sk98lin */
919         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
920             hw->chip_rev == CHIP_REV_YU_FE2_A0)
921                 reg = 0x178;
922         sky2_write16(hw, SK_REG(port, RX_GMF_FL_THR), reg);
923
924         /* Configure Tx MAC FIFO */
925         sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_CLR);
926         sky2_write16(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_OPER_ON);
927
928         /* On chips without ram buffer, pause is controled by MAC level */
929         if (!(hw->flags & SKY2_HW_RAM_BUFFER)) {
930                 /* Pause threshold is scaled by 8 in bytes */
931                 if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
932                     hw->chip_rev == CHIP_REV_YU_FE2_A0)
933                         reg = 1568 / 8;
934                 else
935                         reg = 1024 / 8;
936                 sky2_write16(hw, SK_REG(port, RX_GMF_UP_THR), reg);
937                 sky2_write16(hw, SK_REG(port, RX_GMF_LP_THR), 768 / 8);
938
939                 sky2_set_tx_stfwd(hw, port);
940         }
941
942         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
943             hw->chip_rev == CHIP_REV_YU_FE2_A0) {
944                 /* disable dynamic watermark */
945                 reg = sky2_read16(hw, SK_REG(port, TX_GMF_EA));
946                 reg &= ~TX_DYN_WM_ENA;
947                 sky2_write16(hw, SK_REG(port, TX_GMF_EA), reg);
948         }
949 }
950
951 /* Assign Ram Buffer allocation to queue */
952 static void sky2_ramset(struct sky2_hw *hw, u16 q, u32 start, u32 space)
953 {
954         u32 end;
955
956         /* convert from K bytes to qwords used for hw register */
957         start *= 1024/8;
958         space *= 1024/8;
959         end = start + space - 1;
960
961         sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR);
962         sky2_write32(hw, RB_ADDR(q, RB_START), start);
963         sky2_write32(hw, RB_ADDR(q, RB_END), end);
964         sky2_write32(hw, RB_ADDR(q, RB_WP), start);
965         sky2_write32(hw, RB_ADDR(q, RB_RP), start);
966
967         if (q == Q_R1 || q == Q_R2) {
968                 u32 tp = space - space/4;
969
970                 /* On receive queue's set the thresholds
971                  * give receiver priority when > 3/4 full
972                  * send pause when down to 2K
973                  */
974                 sky2_write32(hw, RB_ADDR(q, RB_RX_UTHP), tp);
975                 sky2_write32(hw, RB_ADDR(q, RB_RX_LTHP), space/2);
976
977                 tp = space - 2048/8;
978                 sky2_write32(hw, RB_ADDR(q, RB_RX_UTPP), tp);
979                 sky2_write32(hw, RB_ADDR(q, RB_RX_LTPP), space/4);
980         } else {
981                 /* Enable store & forward on Tx queue's because
982                  * Tx FIFO is only 1K on Yukon
983                  */
984                 sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_STFWD);
985         }
986
987         sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_OP_MD);
988         sky2_read8(hw, RB_ADDR(q, RB_CTRL));
989 }
990
991 /* Setup Bus Memory Interface */
992 static void sky2_qset(struct sky2_hw *hw, u16 q)
993 {
994         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_RESET);
995         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_OPER_INIT);
996         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_FIFO_OP_ON);
997         sky2_write32(hw, Q_ADDR(q, Q_WM),  BMU_WM_DEFAULT);
998 }
999
1000 /* Setup prefetch unit registers. This is the interface between
1001  * hardware and driver list elements
1002  */
1003 static void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr,
1004                                dma_addr_t addr, u32 last)
1005 {
1006         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
1007         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_CLR);
1008         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), upper_32_bits(addr));
1009         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), lower_32_bits(addr));
1010         sky2_write16(hw, Y2_QADDR(qaddr, PREF_UNIT_LAST_IDX), last);
1011         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_OP_ON);
1012
1013         sky2_read32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL));
1014 }
1015
1016 static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2, u16 *slot)
1017 {
1018         struct sky2_tx_le *le = sky2->tx_le + *slot;
1019
1020         *slot = RING_NEXT(*slot, sky2->tx_ring_size);
1021         le->ctrl = 0;
1022         return le;
1023 }
1024
1025 static void tx_init(struct sky2_port *sky2)
1026 {
1027         struct sky2_tx_le *le;
1028
1029         sky2->tx_prod = sky2->tx_cons = 0;
1030         sky2->tx_tcpsum = 0;
1031         sky2->tx_last_mss = 0;
1032
1033         le = get_tx_le(sky2, &sky2->tx_prod);
1034         le->addr = 0;
1035         le->opcode = OP_ADDR64 | HW_OWNER;
1036         sky2->tx_last_upper = 0;
1037 }
1038
1039 /* Update chip's next pointer */
1040 static inline void sky2_put_idx(struct sky2_hw *hw, unsigned q, u16 idx)
1041 {
1042         /* Make sure write' to descriptors are complete before we tell hardware */
1043         wmb();
1044         sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), idx);
1045
1046         /* Synchronize I/O on since next processor may write to tail */
1047         mmiowb();
1048 }
1049
1050
1051 static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2)
1052 {
1053         struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put;
1054         sky2->rx_put = RING_NEXT(sky2->rx_put, RX_LE_SIZE);
1055         le->ctrl = 0;
1056         return le;
1057 }
1058
1059 static unsigned sky2_get_rx_threshold(struct sky2_port* sky2)
1060 {
1061         unsigned size;
1062
1063         /* Space needed for frame data + headers rounded up */
1064         size = roundup(sky2->netdev->mtu + ETH_HLEN + VLAN_HLEN, 8);
1065
1066         /* Stopping point for hardware truncation */
1067         return (size - 8) / sizeof(u32);
1068 }
1069
1070 static unsigned sky2_get_rx_data_size(struct sky2_port* sky2)
1071 {
1072         struct rx_ring_info *re;
1073         unsigned size;
1074
1075         /* Space needed for frame data + headers rounded up */
1076         size = roundup(sky2->netdev->mtu + ETH_HLEN + VLAN_HLEN, 8);
1077
1078         sky2->rx_nfrags = size >> PAGE_SHIFT;
1079         BUG_ON(sky2->rx_nfrags > ARRAY_SIZE(re->frag_addr));
1080
1081         /* Compute residue after pages */
1082         size -= sky2->rx_nfrags << PAGE_SHIFT;
1083
1084         /* Optimize to handle small packets and headers */
1085         if (size < copybreak)
1086                 size = copybreak;
1087         if (size < ETH_HLEN)
1088                 size = ETH_HLEN;
1089
1090         return size;
1091 }
1092
1093 /* Build description to hardware for one receive segment */
1094 static void sky2_rx_add(struct sky2_port *sky2,  u8 op,
1095                         dma_addr_t map, unsigned len)
1096 {
1097         struct sky2_rx_le *le;
1098
1099         if (sizeof(dma_addr_t) > sizeof(u32)) {
1100                 le = sky2_next_rx(sky2);
1101                 le->addr = cpu_to_le32(upper_32_bits(map));
1102                 le->opcode = OP_ADDR64 | HW_OWNER;
1103         }
1104
1105         le = sky2_next_rx(sky2);
1106         le->addr = cpu_to_le32(lower_32_bits(map));
1107         le->length = cpu_to_le16(len);
1108         le->opcode = op | HW_OWNER;
1109 }
1110
1111 /* Build description to hardware for one possibly fragmented skb */
1112 static void sky2_rx_submit(struct sky2_port *sky2,
1113                            const struct rx_ring_info *re)
1114 {
1115         int i;
1116
1117         sky2_rx_add(sky2, OP_PACKET, re->data_addr, sky2->rx_data_size);
1118
1119         for (i = 0; i < skb_shinfo(re->skb)->nr_frags; i++)
1120                 sky2_rx_add(sky2, OP_BUFFER, re->frag_addr[i], PAGE_SIZE);
1121 }
1122
1123
1124 static int sky2_rx_map_skb(struct pci_dev *pdev, struct rx_ring_info *re,
1125                             unsigned size)
1126 {
1127         struct sk_buff *skb = re->skb;
1128         int i;
1129
1130         re->data_addr = pci_map_single(pdev, skb->data, size, PCI_DMA_FROMDEVICE);
1131         if (pci_dma_mapping_error(pdev, re->data_addr))
1132                 goto mapping_error;
1133
1134         pci_unmap_len_set(re, data_size, size);
1135
1136         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1137                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1138
1139                 re->frag_addr[i] = pci_map_page(pdev, frag->page,
1140                                                 frag->page_offset,
1141                                                 frag->size,
1142                                                 PCI_DMA_FROMDEVICE);
1143
1144                 if (pci_dma_mapping_error(pdev, re->frag_addr[i]))
1145                         goto map_page_error;
1146         }
1147         return 0;
1148
1149 map_page_error:
1150         while (--i >= 0) {
1151                 pci_unmap_page(pdev, re->frag_addr[i],
1152                                skb_shinfo(skb)->frags[i].size,
1153                                PCI_DMA_FROMDEVICE);
1154         }
1155
1156         pci_unmap_single(pdev, re->data_addr, pci_unmap_len(re, data_size),
1157                          PCI_DMA_FROMDEVICE);
1158
1159 mapping_error:
1160         if (net_ratelimit())
1161                 dev_warn(&pdev->dev, "%s: rx mapping error\n",
1162                          skb->dev->name);
1163         return -EIO;
1164 }
1165
1166 static void sky2_rx_unmap_skb(struct pci_dev *pdev, struct rx_ring_info *re)
1167 {
1168         struct sk_buff *skb = re->skb;
1169         int i;
1170
1171         pci_unmap_single(pdev, re->data_addr, pci_unmap_len(re, data_size),
1172                          PCI_DMA_FROMDEVICE);
1173
1174         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1175                 pci_unmap_page(pdev, re->frag_addr[i],
1176                                skb_shinfo(skb)->frags[i].size,
1177                                PCI_DMA_FROMDEVICE);
1178 }
1179
1180 /* Tell chip where to start receive checksum.
1181  * Actually has two checksums, but set both same to avoid possible byte
1182  * order problems.
1183  */
1184 static void rx_set_checksum(struct sky2_port *sky2)
1185 {
1186         struct sky2_rx_le *le = sky2_next_rx(sky2);
1187
1188         le->addr = cpu_to_le32((ETH_HLEN << 16) | ETH_HLEN);
1189         le->ctrl = 0;
1190         le->opcode = OP_TCPSTART | HW_OWNER;
1191
1192         sky2_write32(sky2->hw,
1193                      Q_ADDR(rxqaddr[sky2->port], Q_CSR),
1194                      (sky2->flags & SKY2_FLAG_RX_CHECKSUM)
1195                      ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM);
1196 }
1197
1198 /*
1199  * The RX Stop command will not work for Yukon-2 if the BMU does not
1200  * reach the end of packet and since we can't make sure that we have
1201  * incoming data, we must reset the BMU while it is not doing a DMA
1202  * transfer. Since it is possible that the RX path is still active,
1203  * the RX RAM buffer will be stopped first, so any possible incoming
1204  * data will not trigger a DMA. After the RAM buffer is stopped, the
1205  * BMU is polled until any DMA in progress is ended and only then it
1206  * will be reset.
1207  */
1208 static void sky2_rx_stop(struct sky2_port *sky2)
1209 {
1210         struct sky2_hw *hw = sky2->hw;
1211         unsigned rxq = rxqaddr[sky2->port];
1212         int i;
1213
1214         /* disable the RAM Buffer receive queue */
1215         sky2_write8(hw, RB_ADDR(rxq, RB_CTRL), RB_DIS_OP_MD);
1216
1217         for (i = 0; i < 0xffff; i++)
1218                 if (sky2_read8(hw, RB_ADDR(rxq, Q_RSL))
1219                     == sky2_read8(hw, RB_ADDR(rxq, Q_RL)))
1220                         goto stopped;
1221
1222         netdev_warn(sky2->netdev, "receiver stop failed\n");
1223 stopped:
1224         sky2_write32(hw, Q_ADDR(rxq, Q_CSR), BMU_RST_SET | BMU_FIFO_RST);
1225
1226         /* reset the Rx prefetch unit */
1227         sky2_write32(hw, Y2_QADDR(rxq, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
1228         mmiowb();
1229 }
1230
1231 /* Clean out receive buffer area, assumes receiver hardware stopped */
1232 static void sky2_rx_clean(struct sky2_port *sky2)
1233 {
1234         unsigned i;
1235
1236         memset(sky2->rx_le, 0, RX_LE_BYTES);
1237         for (i = 0; i < sky2->rx_pending; i++) {
1238                 struct rx_ring_info *re = sky2->rx_ring + i;
1239
1240                 if (re->skb) {
1241                         sky2_rx_unmap_skb(sky2->hw->pdev, re);
1242                         kfree_skb(re->skb);
1243                         re->skb = NULL;
1244                 }
1245         }
1246 }
1247
1248 /* Basic MII support */
1249 static int sky2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1250 {
1251         struct mii_ioctl_data *data = if_mii(ifr);
1252         struct sky2_port *sky2 = netdev_priv(dev);
1253         struct sky2_hw *hw = sky2->hw;
1254         int err = -EOPNOTSUPP;
1255
1256         if (!netif_running(dev))
1257                 return -ENODEV; /* Phy still in reset */
1258
1259         switch (cmd) {
1260         case SIOCGMIIPHY:
1261                 data->phy_id = PHY_ADDR_MARV;
1262
1263                 /* fallthru */
1264         case SIOCGMIIREG: {
1265                 u16 val = 0;
1266
1267                 spin_lock_bh(&sky2->phy_lock);
1268                 err = __gm_phy_read(hw, sky2->port, data->reg_num & 0x1f, &val);
1269                 spin_unlock_bh(&sky2->phy_lock);
1270
1271                 data->val_out = val;
1272                 break;
1273         }
1274
1275         case SIOCSMIIREG:
1276                 spin_lock_bh(&sky2->phy_lock);
1277                 err = gm_phy_write(hw, sky2->port, data->reg_num & 0x1f,
1278                                    data->val_in);
1279                 spin_unlock_bh(&sky2->phy_lock);
1280                 break;
1281         }
1282         return err;
1283 }
1284
1285 #ifdef SKY2_VLAN_TAG_USED
1286 static void sky2_set_vlan_mode(struct sky2_hw *hw, u16 port, bool onoff)
1287 {
1288         if (onoff) {
1289                 sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T),
1290                              RX_VLAN_STRIP_ON);
1291                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T),
1292                              TX_VLAN_TAG_ON);
1293         } else {
1294                 sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T),
1295                              RX_VLAN_STRIP_OFF);
1296                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T),
1297                              TX_VLAN_TAG_OFF);
1298         }
1299 }
1300
1301 static void sky2_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
1302 {
1303         struct sky2_port *sky2 = netdev_priv(dev);
1304         struct sky2_hw *hw = sky2->hw;
1305         u16 port = sky2->port;
1306
1307         netif_tx_lock_bh(dev);
1308         napi_disable(&hw->napi);
1309
1310         sky2->vlgrp = grp;
1311         sky2_set_vlan_mode(hw, port, grp != NULL);
1312
1313         sky2_read32(hw, B0_Y2_SP_LISR);
1314         napi_enable(&hw->napi);
1315         netif_tx_unlock_bh(dev);
1316 }
1317 #endif
1318
1319 /* Amount of required worst case padding in rx buffer */
1320 static inline unsigned sky2_rx_pad(const struct sky2_hw *hw)
1321 {
1322         return (hw->flags & SKY2_HW_RAM_BUFFER) ? 8 : 2;
1323 }
1324
1325 /*
1326  * Allocate an skb for receiving. If the MTU is large enough
1327  * make the skb non-linear with a fragment list of pages.
1328  */
1329 static struct sk_buff *sky2_rx_alloc(struct sky2_port *sky2)
1330 {
1331         struct sk_buff *skb;
1332         int i;
1333
1334         skb = netdev_alloc_skb(sky2->netdev,
1335                                sky2->rx_data_size + sky2_rx_pad(sky2->hw));
1336         if (!skb)
1337                 goto nomem;
1338
1339         if (sky2->hw->flags & SKY2_HW_RAM_BUFFER) {
1340                 unsigned char *start;
1341                 /*
1342                  * Workaround for a bug in FIFO that cause hang
1343                  * if the FIFO if the receive buffer is not 64 byte aligned.
1344                  * The buffer returned from netdev_alloc_skb is
1345                  * aligned except if slab debugging is enabled.
1346                  */
1347                 start = PTR_ALIGN(skb->data, 8);
1348                 skb_reserve(skb, start - skb->data);
1349         } else
1350                 skb_reserve(skb, NET_IP_ALIGN);
1351
1352         for (i = 0; i < sky2->rx_nfrags; i++) {
1353                 struct page *page = alloc_page(GFP_ATOMIC);
1354
1355                 if (!page)
1356                         goto free_partial;
1357                 skb_fill_page_desc(skb, i, page, 0, PAGE_SIZE);
1358         }
1359
1360         return skb;
1361 free_partial:
1362         kfree_skb(skb);
1363 nomem:
1364         return NULL;
1365 }
1366
1367 static inline void sky2_rx_update(struct sky2_port *sky2, unsigned rxq)
1368 {
1369         sky2_put_idx(sky2->hw, rxq, sky2->rx_put);
1370 }
1371
1372 static int sky2_alloc_rx_skbs(struct sky2_port *sky2)
1373 {
1374         struct sky2_hw *hw = sky2->hw;
1375         unsigned i;
1376
1377         sky2->rx_data_size = sky2_get_rx_data_size(sky2);
1378
1379         /* Fill Rx ring */
1380         for (i = 0; i < sky2->rx_pending; i++) {
1381                 struct rx_ring_info *re = sky2->rx_ring + i;
1382
1383                 re->skb = sky2_rx_alloc(sky2);
1384                 if (!re->skb)
1385                         return -ENOMEM;
1386
1387                 if (sky2_rx_map_skb(hw->pdev, re, sky2->rx_data_size)) {
1388                         dev_kfree_skb(re->skb);
1389                         re->skb = NULL;
1390                         return -ENOMEM;
1391                 }
1392         }
1393         return 0;
1394 }
1395
1396 /*
1397  * Setup receiver buffer pool.
1398  * Normal case this ends up creating one list element for skb
1399  * in the receive ring. Worst case if using large MTU and each
1400  * allocation falls on a different 64 bit region, that results
1401  * in 6 list elements per ring entry.
1402  * One element is used for checksum enable/disable, and one
1403  * extra to avoid wrap.
1404  */
1405 static void sky2_rx_start(struct sky2_port *sky2)
1406 {
1407         struct sky2_hw *hw = sky2->hw;
1408         struct rx_ring_info *re;
1409         unsigned rxq = rxqaddr[sky2->port];
1410         unsigned i, thresh;
1411
1412         sky2->rx_put = sky2->rx_next = 0;
1413         sky2_qset(hw, rxq);
1414
1415         /* On PCI express lowering the watermark gives better performance */
1416         if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP))
1417                 sky2_write32(hw, Q_ADDR(rxq, Q_WM), BMU_WM_PEX);
1418
1419         /* These chips have no ram buffer?
1420          * MAC Rx RAM Read is controlled by hardware */
1421         if (hw->chip_id == CHIP_ID_YUKON_EC_U &&
1422             hw->chip_rev > CHIP_REV_YU_EC_U_A0)
1423                 sky2_write32(hw, Q_ADDR(rxq, Q_TEST), F_M_RX_RAM_DIS);
1424
1425         sky2_prefetch_init(hw, rxq, sky2->rx_le_map, RX_LE_SIZE - 1);
1426
1427         if (!(hw->flags & SKY2_HW_NEW_LE))
1428                 rx_set_checksum(sky2);
1429
1430         /* submit Rx ring */
1431         for (i = 0; i < sky2->rx_pending; i++) {
1432                 re = sky2->rx_ring + i;
1433                 sky2_rx_submit(sky2, re);
1434         }
1435
1436         /*
1437          * The receiver hangs if it receives frames larger than the
1438          * packet buffer. As a workaround, truncate oversize frames, but
1439          * the register is limited to 9 bits, so if you do frames > 2052
1440          * you better get the MTU right!
1441          */
1442         thresh = sky2_get_rx_threshold(sky2);
1443         if (thresh > 0x1ff)
1444                 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_OFF);
1445         else {
1446                 sky2_write16(hw, SK_REG(sky2->port, RX_GMF_TR_THR), thresh);
1447                 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_ON);
1448         }
1449
1450         /* Tell chip about available buffers */
1451         sky2_rx_update(sky2, rxq);
1452
1453         if (hw->chip_id == CHIP_ID_YUKON_EX ||
1454             hw->chip_id == CHIP_ID_YUKON_SUPR) {
1455                 /*
1456                  * Disable flushing of non ASF packets;
1457                  * must be done after initializing the BMUs;
1458                  * drivers without ASF support should do this too, otherwise
1459                  * it may happen that they cannot run on ASF devices;
1460                  * remember that the MAC FIFO isn't reset during initialization.
1461                  */
1462                 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_MACSEC_FLUSH_OFF);
1463         }
1464
1465         if (hw->chip_id >= CHIP_ID_YUKON_SUPR) {
1466                 /* Enable RX Home Address & Routing Header checksum fix */
1467                 sky2_write16(hw, SK_REG(sky2->port, RX_GMF_FL_CTRL),
1468                              RX_IPV6_SA_MOB_ENA | RX_IPV6_DA_MOB_ENA);
1469
1470                 /* Enable TX Home Address & Routing Header checksum fix */
1471                 sky2_write32(hw, Q_ADDR(txqaddr[sky2->port], Q_TEST),
1472                              TBMU_TEST_HOME_ADD_FIX_EN | TBMU_TEST_ROUTING_ADD_FIX_EN);
1473         }
1474 }
1475
1476 static int sky2_alloc_buffers(struct sky2_port *sky2)
1477 {
1478         struct sky2_hw *hw = sky2->hw;
1479
1480         /* must be power of 2 */
1481         sky2->tx_le = pci_alloc_consistent(hw->pdev,
1482                                            sky2->tx_ring_size *
1483                                            sizeof(struct sky2_tx_le),
1484                                            &sky2->tx_le_map);
1485         if (!sky2->tx_le)
1486                 goto nomem;
1487
1488         sky2->tx_ring = kcalloc(sky2->tx_ring_size, sizeof(struct tx_ring_info),
1489                                 GFP_KERNEL);
1490         if (!sky2->tx_ring)
1491                 goto nomem;
1492
1493         sky2->rx_le = pci_alloc_consistent(hw->pdev, RX_LE_BYTES,
1494                                            &sky2->rx_le_map);
1495         if (!sky2->rx_le)
1496                 goto nomem;
1497         memset(sky2->rx_le, 0, RX_LE_BYTES);
1498
1499         sky2->rx_ring = kcalloc(sky2->rx_pending, sizeof(struct rx_ring_info),
1500                                 GFP_KERNEL);
1501         if (!sky2->rx_ring)
1502                 goto nomem;
1503
1504         return sky2_alloc_rx_skbs(sky2);
1505 nomem:
1506         return -ENOMEM;
1507 }
1508
1509 static void sky2_free_buffers(struct sky2_port *sky2)
1510 {
1511         struct sky2_hw *hw = sky2->hw;
1512
1513         sky2_rx_clean(sky2);
1514
1515         if (sky2->rx_le) {
1516                 pci_free_consistent(hw->pdev, RX_LE_BYTES,
1517                                     sky2->rx_le, sky2->rx_le_map);
1518                 sky2->rx_le = NULL;
1519         }
1520         if (sky2->tx_le) {
1521                 pci_free_consistent(hw->pdev,
1522                                     sky2->tx_ring_size * sizeof(struct sky2_tx_le),
1523                                     sky2->tx_le, sky2->tx_le_map);
1524                 sky2->tx_le = NULL;
1525         }
1526         kfree(sky2->tx_ring);
1527         kfree(sky2->rx_ring);
1528
1529         sky2->tx_ring = NULL;
1530         sky2->rx_ring = NULL;
1531 }
1532
1533 static void sky2_hw_up(struct sky2_port *sky2)
1534 {
1535         struct sky2_hw *hw = sky2->hw;
1536         unsigned port = sky2->port;
1537         u32 ramsize;
1538         int cap;
1539         struct net_device *otherdev = hw->dev[sky2->port^1];
1540
1541         tx_init(sky2);
1542
1543         /*
1544          * On dual port PCI-X card, there is an problem where status
1545          * can be received out of order due to split transactions
1546          */
1547         if (otherdev && netif_running(otherdev) &&
1548             (cap = pci_find_capability(hw->pdev, PCI_CAP_ID_PCIX))) {
1549                 u16 cmd;
1550
1551                 cmd = sky2_pci_read16(hw, cap + PCI_X_CMD);
1552                 cmd &= ~PCI_X_CMD_MAX_SPLIT;
1553                 sky2_pci_write16(hw, cap + PCI_X_CMD, cmd);
1554         }
1555
1556         sky2_mac_init(hw, port);
1557
1558         /* Register is number of 4K blocks on internal RAM buffer. */
1559         ramsize = sky2_read8(hw, B2_E_0) * 4;
1560         if (ramsize > 0) {
1561                 u32 rxspace;
1562
1563                 netdev_dbg(sky2->netdev, "ram buffer %dK\n", ramsize);
1564                 if (ramsize < 16)
1565                         rxspace = ramsize / 2;
1566                 else
1567                         rxspace = 8 + (2*(ramsize - 16))/3;
1568
1569                 sky2_ramset(hw, rxqaddr[port], 0, rxspace);
1570                 sky2_ramset(hw, txqaddr[port], rxspace, ramsize - rxspace);
1571
1572                 /* Make sure SyncQ is disabled */
1573                 sky2_write8(hw, RB_ADDR(port == 0 ? Q_XS1 : Q_XS2, RB_CTRL),
1574                             RB_RST_SET);
1575         }
1576
1577         sky2_qset(hw, txqaddr[port]);
1578
1579         /* This is copied from sk98lin 10.0.5.3; no one tells me about erratta's */
1580         if (hw->chip_id == CHIP_ID_YUKON_EX && hw->chip_rev == CHIP_REV_YU_EX_B0)
1581                 sky2_write32(hw, Q_ADDR(txqaddr[port], Q_TEST), F_TX_CHK_AUTO_OFF);
1582
1583         /* Set almost empty threshold */
1584         if (hw->chip_id == CHIP_ID_YUKON_EC_U &&
1585             hw->chip_rev == CHIP_REV_YU_EC_U_A0)
1586                 sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), ECU_TXFF_LEV);
1587
1588         sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map,
1589                            sky2->tx_ring_size - 1);
1590
1591 #ifdef SKY2_VLAN_TAG_USED
1592         sky2_set_vlan_mode(hw, port, sky2->vlgrp != NULL);
1593 #endif
1594
1595         sky2_rx_start(sky2);
1596 }
1597
1598 /* Bring up network interface. */
1599 static int sky2_up(struct net_device *dev)
1600 {
1601         struct sky2_port *sky2 = netdev_priv(dev);
1602         struct sky2_hw *hw = sky2->hw;
1603         unsigned port = sky2->port;
1604         u32 imask;
1605         int err;
1606
1607         netif_carrier_off(dev);
1608
1609         err = sky2_alloc_buffers(sky2);
1610         if (err)
1611                 goto err_out;
1612
1613         sky2_hw_up(sky2);
1614
1615         /* Enable interrupts from phy/mac for port */
1616         imask = sky2_read32(hw, B0_IMSK);
1617         imask |= portirq_msk[port];
1618         sky2_write32(hw, B0_IMSK, imask);
1619         sky2_read32(hw, B0_IMSK);
1620
1621         netif_info(sky2, ifup, dev, "enabling interface\n");
1622
1623         return 0;
1624
1625 err_out:
1626         sky2_free_buffers(sky2);
1627         return err;
1628 }
1629
1630 /* Modular subtraction in ring */
1631 static inline int tx_inuse(const struct sky2_port *sky2)
1632 {
1633         return (sky2->tx_prod - sky2->tx_cons) & (sky2->tx_ring_size - 1);
1634 }
1635
1636 /* Number of list elements available for next tx */
1637 static inline int tx_avail(const struct sky2_port *sky2)
1638 {
1639         return sky2->tx_pending - tx_inuse(sky2);
1640 }
1641
1642 /* Estimate of number of transmit list elements required */
1643 static unsigned tx_le_req(const struct sk_buff *skb)
1644 {
1645         unsigned count;
1646
1647         count = (skb_shinfo(skb)->nr_frags + 1)
1648                 * (sizeof(dma_addr_t) / sizeof(u32));
1649
1650         if (skb_is_gso(skb))
1651                 ++count;
1652         else if (sizeof(dma_addr_t) == sizeof(u32))
1653                 ++count;        /* possible vlan */
1654
1655         if (skb->ip_summed == CHECKSUM_PARTIAL)
1656                 ++count;
1657
1658         return count;
1659 }
1660
1661 static void sky2_tx_unmap(struct pci_dev *pdev, struct tx_ring_info *re)
1662 {
1663         if (re->flags & TX_MAP_SINGLE)
1664                 pci_unmap_single(pdev, pci_unmap_addr(re, mapaddr),
1665                                  pci_unmap_len(re, maplen),
1666                                  PCI_DMA_TODEVICE);
1667         else if (re->flags & TX_MAP_PAGE)
1668                 pci_unmap_page(pdev, pci_unmap_addr(re, mapaddr),
1669                                pci_unmap_len(re, maplen),
1670                                PCI_DMA_TODEVICE);
1671         re->flags = 0;
1672 }
1673
1674 /*
1675  * Put one packet in ring for transmit.
1676  * A single packet can generate multiple list elements, and
1677  * the number of ring elements will probably be less than the number
1678  * of list elements used.
1679  */
1680 static netdev_tx_t sky2_xmit_frame(struct sk_buff *skb,
1681                                    struct net_device *dev)
1682 {
1683         struct sky2_port *sky2 = netdev_priv(dev);
1684         struct sky2_hw *hw = sky2->hw;
1685         struct sky2_tx_le *le = NULL;
1686         struct tx_ring_info *re;
1687         unsigned i, len;
1688         dma_addr_t mapping;
1689         u32 upper;
1690         u16 slot;
1691         u16 mss;
1692         u8 ctrl;
1693
1694         if (unlikely(tx_avail(sky2) < tx_le_req(skb)))
1695                 return NETDEV_TX_BUSY;
1696
1697         len = skb_headlen(skb);
1698         mapping = pci_map_single(hw->pdev, skb->data, len, PCI_DMA_TODEVICE);
1699
1700         if (pci_dma_mapping_error(hw->pdev, mapping))
1701                 goto mapping_error;
1702
1703         slot = sky2->tx_prod;
1704         netif_printk(sky2, tx_queued, KERN_DEBUG, dev,
1705                      "tx queued, slot %u, len %d\n", slot, skb->len);
1706
1707         /* Send high bits if needed */
1708         upper = upper_32_bits(mapping);
1709         if (upper != sky2->tx_last_upper) {
1710                 le = get_tx_le(sky2, &slot);
1711                 le->addr = cpu_to_le32(upper);
1712                 sky2->tx_last_upper = upper;
1713                 le->opcode = OP_ADDR64 | HW_OWNER;
1714         }
1715
1716         /* Check for TCP Segmentation Offload */
1717         mss = skb_shinfo(skb)->gso_size;
1718         if (mss != 0) {
1719
1720                 if (!(hw->flags & SKY2_HW_NEW_LE))
1721                         mss += ETH_HLEN + ip_hdrlen(skb) + tcp_hdrlen(skb);
1722
1723                 if (mss != sky2->tx_last_mss) {
1724                         le = get_tx_le(sky2, &slot);
1725                         le->addr = cpu_to_le32(mss);
1726
1727                         if (hw->flags & SKY2_HW_NEW_LE)
1728                                 le->opcode = OP_MSS | HW_OWNER;
1729                         else
1730                                 le->opcode = OP_LRGLEN | HW_OWNER;
1731                         sky2->tx_last_mss = mss;
1732                 }
1733         }
1734
1735         ctrl = 0;
1736 #ifdef SKY2_VLAN_TAG_USED
1737         /* Add VLAN tag, can piggyback on LRGLEN or ADDR64 */
1738         if (sky2->vlgrp && vlan_tx_tag_present(skb)) {
1739                 if (!le) {
1740                         le = get_tx_le(sky2, &slot);
1741                         le->addr = 0;
1742                         le->opcode = OP_VLAN|HW_OWNER;
1743                 } else
1744                         le->opcode |= OP_VLAN;
1745                 le->length = cpu_to_be16(vlan_tx_tag_get(skb));
1746                 ctrl |= INS_VLAN;
1747         }
1748 #endif
1749
1750         /* Handle TCP checksum offload */
1751         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1752                 /* On Yukon EX (some versions) encoding change. */
1753                 if (hw->flags & SKY2_HW_AUTO_TX_SUM)
1754                         ctrl |= CALSUM; /* auto checksum */
1755                 else {
1756                         const unsigned offset = skb_transport_offset(skb);
1757                         u32 tcpsum;
1758
1759                         tcpsum = offset << 16;                  /* sum start */
1760                         tcpsum |= offset + skb->csum_offset;    /* sum write */
1761
1762                         ctrl |= CALSUM | WR_SUM | INIT_SUM | LOCK_SUM;
1763                         if (ip_hdr(skb)->protocol == IPPROTO_UDP)
1764                                 ctrl |= UDPTCP;
1765
1766                         if (tcpsum != sky2->tx_tcpsum) {
1767                                 sky2->tx_tcpsum = tcpsum;
1768
1769                                 le = get_tx_le(sky2, &slot);
1770                                 le->addr = cpu_to_le32(tcpsum);
1771                                 le->length = 0; /* initial checksum value */
1772                                 le->ctrl = 1;   /* one packet */
1773                                 le->opcode = OP_TCPLISW | HW_OWNER;
1774                         }
1775                 }
1776         }
1777
1778         re = sky2->tx_ring + slot;
1779         re->flags = TX_MAP_SINGLE;
1780         pci_unmap_addr_set(re, mapaddr, mapping);
1781         pci_unmap_len_set(re, maplen, len);
1782
1783         le = get_tx_le(sky2, &slot);
1784         le->addr = cpu_to_le32(lower_32_bits(mapping));
1785         le->length = cpu_to_le16(len);
1786         le->ctrl = ctrl;
1787         le->opcode = mss ? (OP_LARGESEND | HW_OWNER) : (OP_PACKET | HW_OWNER);
1788
1789
1790         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1791                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1792
1793                 mapping = pci_map_page(hw->pdev, frag->page, frag->page_offset,
1794                                        frag->size, PCI_DMA_TODEVICE);
1795
1796                 if (pci_dma_mapping_error(hw->pdev, mapping))
1797                         goto mapping_unwind;
1798
1799                 upper = upper_32_bits(mapping);
1800                 if (upper != sky2->tx_last_upper) {
1801                         le = get_tx_le(sky2, &slot);
1802                         le->addr = cpu_to_le32(upper);
1803                         sky2->tx_last_upper = upper;
1804                         le->opcode = OP_ADDR64 | HW_OWNER;
1805                 }
1806
1807                 re = sky2->tx_ring + slot;
1808                 re->flags = TX_MAP_PAGE;
1809                 pci_unmap_addr_set(re, mapaddr, mapping);
1810                 pci_unmap_len_set(re, maplen, frag->size);
1811
1812                 le = get_tx_le(sky2, &slot);
1813                 le->addr = cpu_to_le32(lower_32_bits(mapping));
1814                 le->length = cpu_to_le16(frag->size);
1815                 le->ctrl = ctrl;
1816                 le->opcode = OP_BUFFER | HW_OWNER;
1817         }
1818
1819         re->skb = skb;
1820         le->ctrl |= EOP;
1821
1822         sky2->tx_prod = slot;
1823
1824         if (tx_avail(sky2) <= MAX_SKB_TX_LE)
1825                 netif_stop_queue(dev);
1826
1827         sky2_put_idx(hw, txqaddr[sky2->port], sky2->tx_prod);
1828
1829         return NETDEV_TX_OK;
1830
1831 mapping_unwind:
1832         for (i = sky2->tx_prod; i != slot; i = RING_NEXT(i, sky2->tx_ring_size)) {
1833                 re = sky2->tx_ring + i;
1834
1835                 sky2_tx_unmap(hw->pdev, re);
1836         }
1837
1838 mapping_error:
1839         if (net_ratelimit())
1840                 dev_warn(&hw->pdev->dev, "%s: tx mapping error\n", dev->name);
1841         dev_kfree_skb(skb);
1842         return NETDEV_TX_OK;
1843 }
1844
1845 /*
1846  * Free ring elements from starting at tx_cons until "done"
1847  *
1848  * NB:
1849  *  1. The hardware will tell us about partial completion of multi-part
1850  *     buffers so make sure not to free skb to early.
1851  *  2. This may run in parallel start_xmit because the it only
1852  *     looks at the tail of the queue of FIFO (tx_cons), not
1853  *     the head (tx_prod)
1854  */
1855 static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
1856 {
1857         struct net_device *dev = sky2->netdev;
1858         unsigned idx;
1859
1860         BUG_ON(done >= sky2->tx_ring_size);
1861
1862         for (idx = sky2->tx_cons; idx != done;
1863              idx = RING_NEXT(idx, sky2->tx_ring_size)) {
1864                 struct tx_ring_info *re = sky2->tx_ring + idx;
1865                 struct sk_buff *skb = re->skb;
1866
1867                 sky2_tx_unmap(sky2->hw->pdev, re);
1868
1869                 if (skb) {
1870                         netif_printk(sky2, tx_done, KERN_DEBUG, dev,
1871                                      "tx done %u\n", idx);
1872
1873                         dev->stats.tx_packets++;
1874                         dev->stats.tx_bytes += skb->len;
1875
1876                         re->skb = NULL;
1877                         dev_kfree_skb_any(skb);
1878
1879                         sky2->tx_next = RING_NEXT(idx, sky2->tx_ring_size);
1880                 }
1881         }
1882
1883         sky2->tx_cons = idx;
1884         smp_mb();
1885 }
1886
1887 static void sky2_tx_reset(struct sky2_hw *hw, unsigned port)
1888 {
1889         /* Disable Force Sync bit and Enable Alloc bit */
1890         sky2_write8(hw, SK_REG(port, TXA_CTRL),
1891                     TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
1892
1893         /* Stop Interval Timer and Limit Counter of Tx Arbiter */
1894         sky2_write32(hw, SK_REG(port, TXA_ITI_INI), 0L);
1895         sky2_write32(hw, SK_REG(port, TXA_LIM_INI), 0L);
1896
1897         /* Reset the PCI FIFO of the async Tx queue */
1898         sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR),
1899                      BMU_RST_SET | BMU_FIFO_RST);
1900
1901         /* Reset the Tx prefetch units */
1902         sky2_write32(hw, Y2_QADDR(txqaddr[port], PREF_UNIT_CTRL),
1903                      PREF_UNIT_RST_SET);
1904
1905         sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), RB_RST_SET);
1906         sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET);
1907 }
1908
1909 static void sky2_hw_down(struct sky2_port *sky2)
1910 {
1911         struct sky2_hw *hw = sky2->hw;
1912         unsigned port = sky2->port;
1913         u16 ctrl;
1914
1915         /* Force flow control off */
1916         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
1917
1918         /* Stop transmitter */
1919         sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_STOP);
1920         sky2_read32(hw, Q_ADDR(txqaddr[port], Q_CSR));
1921
1922         sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL),
1923                      RB_RST_SET | RB_DIS_OP_MD);
1924
1925         ctrl = gma_read16(hw, port, GM_GP_CTRL);
1926         ctrl &= ~(GM_GPCR_TX_ENA | GM_GPCR_RX_ENA);
1927         gma_write16(hw, port, GM_GP_CTRL, ctrl);
1928
1929         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
1930
1931         /* Workaround shared GMAC reset */
1932         if (!(hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 &&
1933               port == 0 && hw->dev[1] && netif_running(hw->dev[1])))
1934                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET);
1935
1936         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET);
1937
1938         /* Force any delayed status interrrupt and NAPI */
1939         sky2_write32(hw, STAT_LEV_TIMER_CNT, 0);
1940         sky2_write32(hw, STAT_TX_TIMER_CNT, 0);
1941         sky2_write32(hw, STAT_ISR_TIMER_CNT, 0);
1942         sky2_read8(hw, STAT_ISR_TIMER_CTRL);
1943
1944         sky2_rx_stop(sky2);
1945
1946         spin_lock_bh(&sky2->phy_lock);
1947         sky2_phy_power_down(hw, port);
1948         spin_unlock_bh(&sky2->phy_lock);
1949
1950         sky2_tx_reset(hw, port);
1951
1952         /* Free any pending frames stuck in HW queue */
1953         sky2_tx_complete(sky2, sky2->tx_prod);
1954 }
1955
1956 /* Network shutdown */
1957 static int sky2_down(struct net_device *dev)
1958 {
1959         struct sky2_port *sky2 = netdev_priv(dev);
1960         struct sky2_hw *hw = sky2->hw;
1961
1962         /* Never really got started! */
1963         if (!sky2->tx_le)
1964                 return 0;
1965
1966         netif_info(sky2, ifdown, dev, "disabling interface\n");
1967
1968         /* Disable port IRQ */
1969         sky2_write32(hw, B0_IMSK,
1970                      sky2_read32(hw, B0_IMSK) & ~portirq_msk[sky2->port]);
1971         sky2_read32(hw, B0_IMSK);
1972
1973         synchronize_irq(hw->pdev->irq);
1974         napi_synchronize(&hw->napi);
1975
1976         sky2_hw_down(sky2);
1977
1978         sky2_free_buffers(sky2);
1979
1980         return 0;
1981 }
1982
1983 static u16 sky2_phy_speed(const struct sky2_hw *hw, u16 aux)
1984 {
1985         if (hw->flags & SKY2_HW_FIBRE_PHY)
1986                 return SPEED_1000;
1987
1988         if (!(hw->flags & SKY2_HW_GIGABIT)) {
1989                 if (aux & PHY_M_PS_SPEED_100)
1990                         return SPEED_100;
1991                 else
1992                         return SPEED_10;
1993         }
1994
1995         switch (aux & PHY_M_PS_SPEED_MSK) {
1996         case PHY_M_PS_SPEED_1000:
1997                 return SPEED_1000;
1998         case PHY_M_PS_SPEED_100:
1999                 return SPEED_100;
2000         default:
2001                 return SPEED_10;
2002         }
2003 }
2004
2005 static void sky2_link_up(struct sky2_port *sky2)
2006 {
2007         struct sky2_hw *hw = sky2->hw;
2008         unsigned port = sky2->port;
2009         u16 reg;
2010         static const char *fc_name[] = {
2011                 [FC_NONE]       = "none",
2012                 [FC_TX]         = "tx",
2013                 [FC_RX]         = "rx",
2014                 [FC_BOTH]       = "both",
2015         };
2016
2017         /* enable Rx/Tx */
2018         reg = gma_read16(hw, port, GM_GP_CTRL);
2019         reg |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA;
2020         gma_write16(hw, port, GM_GP_CTRL, reg);
2021
2022         gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK);
2023
2024         netif_carrier_on(sky2->netdev);
2025
2026         mod_timer(&hw->watchdog_timer, jiffies + 1);
2027
2028         /* Turn on link LED */
2029         sky2_write8(hw, SK_REG(port, LNK_LED_REG),
2030                     LINKLED_ON | LINKLED_BLINK_OFF | LINKLED_LINKSYNC_OFF);
2031
2032         netif_info(sky2, link, sky2->netdev,
2033                    "Link is up at %d Mbps, %s duplex, flow control %s\n",
2034                    sky2->speed,
2035                    sky2->duplex == DUPLEX_FULL ? "full" : "half",
2036                    fc_name[sky2->flow_status]);
2037 }
2038
2039 static void sky2_link_down(struct sky2_port *sky2)
2040 {
2041         struct sky2_hw *hw = sky2->hw;
2042         unsigned port = sky2->port;
2043         u16 reg;
2044
2045         gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0);
2046
2047         reg = gma_read16(hw, port, GM_GP_CTRL);
2048         reg &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
2049         gma_write16(hw, port, GM_GP_CTRL, reg);
2050
2051         netif_carrier_off(sky2->netdev);
2052
2053         /* Turn off link LED */
2054         sky2_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF);
2055
2056         netif_info(sky2, link, sky2->netdev, "Link is down\n");
2057
2058         sky2_phy_init(hw, port);
2059 }
2060
2061 static enum flow_control sky2_flow(int rx, int tx)
2062 {
2063         if (rx)
2064                 return tx ? FC_BOTH : FC_RX;
2065         else
2066                 return tx ? FC_TX : FC_NONE;
2067 }
2068
2069 static int sky2_autoneg_done(struct sky2_port *sky2, u16 aux)
2070 {
2071         struct sky2_hw *hw = sky2->hw;
2072         unsigned port = sky2->port;
2073         u16 advert, lpa;
2074
2075         advert = gm_phy_read(hw, port, PHY_MARV_AUNE_ADV);
2076         lpa = gm_phy_read(hw, port, PHY_MARV_AUNE_LP);
2077         if (lpa & PHY_M_AN_RF) {
2078                 netdev_err(sky2->netdev, "remote fault\n");
2079                 return -1;
2080         }
2081
2082         if (!(aux & PHY_M_PS_SPDUP_RES)) {
2083                 netdev_err(sky2->netdev, "speed/duplex mismatch\n");
2084                 return -1;
2085         }
2086
2087         sky2->speed = sky2_phy_speed(hw, aux);
2088         sky2->duplex = (aux & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
2089
2090         /* Since the pause result bits seem to in different positions on
2091          * different chips. look at registers.
2092          */
2093         if (hw->flags & SKY2_HW_FIBRE_PHY) {
2094                 /* Shift for bits in fiber PHY */
2095                 advert &= ~(ADVERTISE_PAUSE_CAP|ADVERTISE_PAUSE_ASYM);
2096                 lpa &= ~(LPA_PAUSE_CAP|LPA_PAUSE_ASYM);
2097
2098                 if (advert & ADVERTISE_1000XPAUSE)
2099                         advert |= ADVERTISE_PAUSE_CAP;
2100                 if (advert & ADVERTISE_1000XPSE_ASYM)
2101                         advert |= ADVERTISE_PAUSE_ASYM;
2102                 if (lpa & LPA_1000XPAUSE)
2103                         lpa |= LPA_PAUSE_CAP;
2104                 if (lpa & LPA_1000XPAUSE_ASYM)
2105                         lpa |= LPA_PAUSE_ASYM;
2106         }
2107
2108         sky2->flow_status = FC_NONE;
2109         if (advert & ADVERTISE_PAUSE_CAP) {
2110                 if (lpa & LPA_PAUSE_CAP)
2111                         sky2->flow_status = FC_BOTH;
2112                 else if (advert & ADVERTISE_PAUSE_ASYM)
2113                         sky2->flow_status = FC_RX;
2114         } else if (advert & ADVERTISE_PAUSE_ASYM) {
2115                 if ((lpa & LPA_PAUSE_CAP) && (lpa & LPA_PAUSE_ASYM))
2116                         sky2->flow_status = FC_TX;
2117         }
2118
2119         if (sky2->duplex == DUPLEX_HALF && sky2->speed < SPEED_1000 &&
2120             !(hw->chip_id == CHIP_ID_YUKON_EC_U || hw->chip_id == CHIP_ID_YUKON_EX))
2121                 sky2->flow_status = FC_NONE;
2122
2123         if (sky2->flow_status & FC_TX)
2124                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON);
2125         else
2126                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
2127
2128         return 0;
2129 }
2130
2131 /* Interrupt from PHY */
2132 static void sky2_phy_intr(struct sky2_hw *hw, unsigned port)
2133 {
2134         struct net_device *dev = hw->dev[port];
2135         struct sky2_port *sky2 = netdev_priv(dev);
2136         u16 istatus, phystat;
2137
2138         if (!netif_running(dev))
2139                 return;
2140
2141         spin_lock(&sky2->phy_lock);
2142         istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT);
2143         phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT);
2144
2145         netif_info(sky2, intr, sky2->netdev, "phy interrupt status 0x%x 0x%x\n",
2146                    istatus, phystat);
2147
2148         if (istatus & PHY_M_IS_AN_COMPL) {
2149                 if (sky2_autoneg_done(sky2, phystat) == 0 &&
2150                     !netif_carrier_ok(dev))
2151                         sky2_link_up(sky2);
2152                 goto out;
2153         }
2154
2155         if (istatus & PHY_M_IS_LSP_CHANGE)
2156                 sky2->speed = sky2_phy_speed(hw, phystat);
2157
2158         if (istatus & PHY_M_IS_DUP_CHANGE)
2159                 sky2->duplex =
2160                     (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
2161
2162         if (istatus & PHY_M_IS_LST_CHANGE) {
2163                 if (phystat & PHY_M_PS_LINK_UP)
2164                         sky2_link_up(sky2);
2165                 else
2166                         sky2_link_down(sky2);
2167         }
2168 out:
2169         spin_unlock(&sky2->phy_lock);
2170 }
2171
2172 /* Special quick link interrupt (Yukon-2 Optima only) */
2173 static void sky2_qlink_intr(struct sky2_hw *hw)
2174 {
2175         struct sky2_port *sky2 = netdev_priv(hw->dev[0]);
2176         u32 imask;
2177         u16 phy;
2178
2179         /* disable irq */
2180         imask = sky2_read32(hw, B0_IMSK);
2181         imask &= ~Y2_IS_PHY_QLNK;
2182         sky2_write32(hw, B0_IMSK, imask);
2183
2184         /* reset PHY Link Detect */
2185         phy = sky2_pci_read16(hw, PSM_CONFIG_REG4);
2186         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2187         sky2_pci_write16(hw, PSM_CONFIG_REG4, phy | 1);
2188         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2189
2190         sky2_link_up(sky2);
2191 }
2192
2193 /* Transmit timeout is only called if we are running, carrier is up
2194  * and tx queue is full (stopped).
2195  */
2196 static void sky2_tx_timeout(struct net_device *dev)
2197 {
2198         struct sky2_port *sky2 = netdev_priv(dev);
2199         struct sky2_hw *hw = sky2->hw;
2200
2201         netif_err(sky2, timer, dev, "tx timeout\n");
2202
2203         netdev_printk(KERN_DEBUG, dev, "transmit ring %u .. %u report=%u done=%u\n",
2204                       sky2->tx_cons, sky2->tx_prod,
2205                       sky2_read16(hw, sky2->port == 0 ? STAT_TXA1_RIDX : STAT_TXA2_RIDX),
2206                       sky2_read16(hw, Q_ADDR(txqaddr[sky2->port], Q_DONE)));
2207
2208         /* can't restart safely under softirq */
2209         schedule_work(&hw->restart_work);
2210 }
2211
2212 static int sky2_change_mtu(struct net_device *dev, int new_mtu)
2213 {
2214         struct sky2_port *sky2 = netdev_priv(dev);
2215         struct sky2_hw *hw = sky2->hw;
2216         unsigned port = sky2->port;
2217         int err;
2218         u16 ctl, mode;
2219         u32 imask;
2220
2221         /* MTU size outside the spec */
2222         if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU)
2223                 return -EINVAL;
2224
2225         /* MTU > 1500 on yukon FE and FE+ not allowed */
2226         if (new_mtu > ETH_DATA_LEN &&
2227             (hw->chip_id == CHIP_ID_YUKON_FE ||
2228              hw->chip_id == CHIP_ID_YUKON_FE_P))
2229                 return -EINVAL;
2230
2231         /* TSO, etc on Yukon Ultra and MTU > 1500 not supported */
2232         if (new_mtu > ETH_DATA_LEN && hw->chip_id == CHIP_ID_YUKON_EC_U)
2233                 dev->features &= ~(NETIF_F_TSO|NETIF_F_SG|NETIF_F_ALL_CSUM);
2234
2235         if (!netif_running(dev)) {
2236                 dev->mtu = new_mtu;
2237                 return 0;
2238         }
2239
2240         imask = sky2_read32(hw, B0_IMSK);
2241         sky2_write32(hw, B0_IMSK, 0);
2242
2243         dev->trans_start = jiffies;     /* prevent tx timeout */
2244         netif_stop_queue(dev);
2245         napi_disable(&hw->napi);
2246
2247         synchronize_irq(hw->pdev->irq);
2248
2249         if (!(hw->flags & SKY2_HW_RAM_BUFFER))
2250                 sky2_set_tx_stfwd(hw, port);
2251
2252         ctl = gma_read16(hw, port, GM_GP_CTRL);
2253         gma_write16(hw, port, GM_GP_CTRL, ctl & ~GM_GPCR_RX_ENA);
2254         sky2_rx_stop(sky2);
2255         sky2_rx_clean(sky2);
2256
2257         dev->mtu = new_mtu;
2258
2259         mode = DATA_BLIND_VAL(DATA_BLIND_DEF) |
2260                 GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
2261
2262         if (dev->mtu > ETH_DATA_LEN)
2263                 mode |= GM_SMOD_JUMBO_ENA;
2264
2265         gma_write16(hw, port, GM_SERIAL_MODE, mode);
2266
2267         sky2_write8(hw, RB_ADDR(rxqaddr[port], RB_CTRL), RB_ENA_OP_MD);
2268
2269         err = sky2_alloc_rx_skbs(sky2);
2270         if (!err)
2271                 sky2_rx_start(sky2);
2272         else
2273                 sky2_rx_clean(sky2);
2274         sky2_write32(hw, B0_IMSK, imask);
2275
2276         sky2_read32(hw, B0_Y2_SP_LISR);
2277         napi_enable(&hw->napi);
2278
2279         if (err)
2280                 dev_close(dev);
2281         else {
2282                 gma_write16(hw, port, GM_GP_CTRL, ctl);
2283
2284                 netif_wake_queue(dev);
2285         }
2286
2287         return err;
2288 }
2289
2290 /* For small just reuse existing skb for next receive */
2291 static struct sk_buff *receive_copy(struct sky2_port *sky2,
2292                                     const struct rx_ring_info *re,
2293                                     unsigned length)
2294 {
2295         struct sk_buff *skb;
2296
2297         skb = netdev_alloc_skb_ip_align(sky2->netdev, length);
2298         if (likely(skb)) {
2299                 pci_dma_sync_single_for_cpu(sky2->hw->pdev, re->data_addr,
2300                                             length, PCI_DMA_FROMDEVICE);
2301                 skb_copy_from_linear_data(re->skb, skb->data, length);
2302                 skb->ip_summed = re->skb->ip_summed;
2303                 skb->csum = re->skb->csum;
2304                 pci_dma_sync_single_for_device(sky2->hw->pdev, re->data_addr,
2305                                                length, PCI_DMA_FROMDEVICE);
2306                 re->skb->ip_summed = CHECKSUM_NONE;
2307                 skb_put(skb, length);
2308         }
2309         return skb;
2310 }
2311
2312 /* Adjust length of skb with fragments to match received data */
2313 static void skb_put_frags(struct sk_buff *skb, unsigned int hdr_space,
2314                           unsigned int length)
2315 {
2316         int i, num_frags;
2317         unsigned int size;
2318
2319         /* put header into skb */
2320         size = min(length, hdr_space);
2321         skb->tail += size;
2322         skb->len += size;
2323         length -= size;
2324
2325         num_frags = skb_shinfo(skb)->nr_frags;
2326         for (i = 0; i < num_frags; i++) {
2327                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2328
2329                 if (length == 0) {
2330                         /* don't need this page */
2331                         __free_page(frag->page);
2332                         --skb_shinfo(skb)->nr_frags;
2333                 } else {
2334                         size = min(length, (unsigned) PAGE_SIZE);
2335
2336                         frag->size = size;
2337                         skb->data_len += size;
2338                         skb->truesize += size;
2339                         skb->len += size;
2340                         length -= size;
2341                 }
2342         }
2343 }
2344
2345 /* Normal packet - take skb from ring element and put in a new one  */
2346 static struct sk_buff *receive_new(struct sky2_port *sky2,
2347                                    struct rx_ring_info *re,
2348                                    unsigned int length)
2349 {
2350         struct sk_buff *skb;
2351         struct rx_ring_info nre;
2352         unsigned hdr_space = sky2->rx_data_size;
2353
2354         nre.skb = sky2_rx_alloc(sky2);
2355         if (unlikely(!nre.skb))
2356                 goto nobuf;
2357
2358         if (sky2_rx_map_skb(sky2->hw->pdev, &nre, hdr_space))
2359                 goto nomap;
2360
2361         skb = re->skb;
2362         sky2_rx_unmap_skb(sky2->hw->pdev, re);
2363         prefetch(skb->data);
2364         *re = nre;
2365
2366         if (skb_shinfo(skb)->nr_frags)
2367                 skb_put_frags(skb, hdr_space, length);
2368         else
2369                 skb_put(skb, length);
2370         return skb;
2371
2372 nomap:
2373         dev_kfree_skb(nre.skb);
2374 nobuf:
2375         return NULL;
2376 }
2377
2378 /*
2379  * Receive one packet.
2380  * For larger packets, get new buffer.
2381  */
2382 static struct sk_buff *sky2_receive(struct net_device *dev,
2383                                     u16 length, u32 status)
2384 {
2385         struct sky2_port *sky2 = netdev_priv(dev);
2386         struct rx_ring_info *re = sky2->rx_ring + sky2->rx_next;
2387         struct sk_buff *skb = NULL;
2388         u16 count = (status & GMR_FS_LEN) >> 16;
2389
2390 #ifdef SKY2_VLAN_TAG_USED
2391         /* Account for vlan tag */
2392         if (sky2->vlgrp && (status & GMR_FS_VLAN))
2393                 count -= VLAN_HLEN;
2394 #endif
2395
2396         netif_printk(sky2, rx_status, KERN_DEBUG, dev,
2397                      "rx slot %u status 0x%x len %d\n",
2398                      sky2->rx_next, status, length);
2399
2400         sky2->rx_next = (sky2->rx_next + 1) % sky2->rx_pending;
2401         prefetch(sky2->rx_ring + sky2->rx_next);
2402
2403         /* This chip has hardware problems that generates bogus status.
2404          * So do only marginal checking and expect higher level protocols
2405          * to handle crap frames.
2406          */
2407         if (sky2->hw->chip_id == CHIP_ID_YUKON_FE_P &&
2408             sky2->hw->chip_rev == CHIP_REV_YU_FE2_A0 &&
2409             length != count)
2410                 goto okay;
2411
2412         if (status & GMR_FS_ANY_ERR)
2413                 goto error;
2414
2415         if (!(status & GMR_FS_RX_OK))
2416                 goto resubmit;
2417
2418         /* if length reported by DMA does not match PHY, packet was truncated */
2419         if (length != count)
2420                 goto len_error;
2421
2422 okay:
2423         if (length < copybreak)
2424                 skb = receive_copy(sky2, re, length);
2425         else
2426                 skb = receive_new(sky2, re, length);
2427
2428         dev->stats.rx_dropped += (skb == NULL);
2429
2430 resubmit:
2431         sky2_rx_submit(sky2, re);
2432
2433         return skb;
2434
2435 len_error:
2436         /* Truncation of overlength packets
2437            causes PHY length to not match MAC length */
2438         ++dev->stats.rx_length_errors;
2439         if (net_ratelimit())
2440                 netif_info(sky2, rx_err, dev,
2441                            "rx length error: status %#x length %d\n",
2442                            status, length);
2443         goto resubmit;
2444
2445 error:
2446         ++dev->stats.rx_errors;
2447         if (status & GMR_FS_RX_FF_OV) {
2448                 dev->stats.rx_over_errors++;
2449                 goto resubmit;
2450         }
2451
2452         if (net_ratelimit())
2453                 netif_info(sky2, rx_err, dev,
2454                            "rx error, status 0x%x length %d\n", status, length);
2455
2456         if (status & (GMR_FS_LONG_ERR | GMR_FS_UN_SIZE))
2457                 dev->stats.rx_length_errors++;
2458         if (status & GMR_FS_FRAGMENT)
2459                 dev->stats.rx_frame_errors++;
2460         if (status & GMR_FS_CRC_ERR)
2461                 dev->stats.rx_crc_errors++;
2462
2463         goto resubmit;
2464 }
2465
2466 /* Transmit complete */
2467 static inline void sky2_tx_done(struct net_device *dev, u16 last)
2468 {
2469         struct sky2_port *sky2 = netdev_priv(dev);
2470
2471         if (netif_running(dev)) {
2472                 sky2_tx_complete(sky2, last);
2473
2474                 /* Wake unless it's detached, and called e.g. from sky2_down() */
2475                 if (tx_avail(sky2) > MAX_SKB_TX_LE + 4)
2476                         netif_wake_queue(dev);
2477         }
2478 }
2479
2480 static inline void sky2_skb_rx(const struct sky2_port *sky2,
2481                                u32 status, struct sk_buff *skb)
2482 {
2483 #ifdef SKY2_VLAN_TAG_USED
2484         u16 vlan_tag = be16_to_cpu(sky2->rx_tag);
2485         if (sky2->vlgrp && (status & GMR_FS_VLAN)) {
2486                 if (skb->ip_summed == CHECKSUM_NONE)
2487                         vlan_hwaccel_receive_skb(skb, sky2->vlgrp, vlan_tag);
2488                 else
2489                         vlan_gro_receive(&sky2->hw->napi, sky2->vlgrp,
2490                                          vlan_tag, skb);
2491                 return;
2492         }
2493 #endif
2494         if (skb->ip_summed == CHECKSUM_NONE)
2495                 netif_receive_skb(skb);
2496         else
2497                 napi_gro_receive(&sky2->hw->napi, skb);
2498 }
2499
2500 static inline void sky2_rx_done(struct sky2_hw *hw, unsigned port,
2501                                 unsigned packets, unsigned bytes)
2502 {
2503         if (packets) {
2504                 struct net_device *dev = hw->dev[port];
2505
2506                 dev->stats.rx_packets += packets;
2507                 dev->stats.rx_bytes += bytes;
2508                 dev->last_rx = jiffies;
2509                 sky2_rx_update(netdev_priv(dev), rxqaddr[port]);
2510         }
2511 }
2512
2513 static void sky2_rx_checksum(struct sky2_port *sky2, u32 status)
2514 {
2515         /* If this happens then driver assuming wrong format for chip type */
2516         BUG_ON(sky2->hw->flags & SKY2_HW_NEW_LE);
2517
2518         /* Both checksum counters are programmed to start at
2519          * the same offset, so unless there is a problem they
2520          * should match. This failure is an early indication that
2521          * hardware receive checksumming won't work.
2522          */
2523         if (likely((u16)(status >> 16) == (u16)status)) {
2524                 struct sk_buff *skb = sky2->rx_ring[sky2->rx_next].skb;
2525                 skb->ip_summed = CHECKSUM_COMPLETE;
2526                 skb->csum = le16_to_cpu(status);
2527         } else {
2528                 dev_notice(&sky2->hw->pdev->dev,
2529                            "%s: receive checksum problem (status = %#x)\n",
2530                            sky2->netdev->name, status);
2531
2532                 /* Disable checksum offload */
2533                 sky2->flags &= ~SKY2_FLAG_RX_CHECKSUM;
2534                 sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
2535                              BMU_DIS_RX_CHKSUM);
2536         }
2537 }
2538
2539 /* Process status response ring */
2540 static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
2541 {
2542         int work_done = 0;
2543         unsigned int total_bytes[2] = { 0 };
2544         unsigned int total_packets[2] = { 0 };
2545
2546         rmb();
2547         do {
2548                 struct sky2_port *sky2;
2549                 struct sky2_status_le *le  = hw->st_le + hw->st_idx;
2550                 unsigned port;
2551                 struct net_device *dev;
2552                 struct sk_buff *skb;
2553                 u32 status;
2554                 u16 length;
2555                 u8 opcode = le->opcode;
2556
2557                 if (!(opcode & HW_OWNER))
2558                         break;
2559
2560                 hw->st_idx = RING_NEXT(hw->st_idx, STATUS_RING_SIZE);
2561
2562                 port = le->css & CSS_LINK_BIT;
2563                 dev = hw->dev[port];
2564                 sky2 = netdev_priv(dev);
2565                 length = le16_to_cpu(le->length);
2566                 status = le32_to_cpu(le->status);
2567
2568                 le->opcode = 0;
2569                 switch (opcode & ~HW_OWNER) {
2570                 case OP_RXSTAT:
2571                         total_packets[port]++;
2572                         total_bytes[port] += length;
2573
2574                         skb = sky2_receive(dev, length, status);
2575                         if (!skb)
2576                                 break;
2577
2578                         /* This chip reports checksum status differently */
2579                         if (hw->flags & SKY2_HW_NEW_LE) {
2580                                 if ((sky2->flags & SKY2_FLAG_RX_CHECKSUM) &&
2581                                     (le->css & (CSS_ISIPV4 | CSS_ISIPV6)) &&
2582                                     (le->css & CSS_TCPUDPCSOK))
2583                                         skb->ip_summed = CHECKSUM_UNNECESSARY;
2584                                 else
2585                                         skb->ip_summed = CHECKSUM_NONE;
2586                         }
2587
2588                         skb->protocol = eth_type_trans(skb, dev);
2589
2590                         sky2_skb_rx(sky2, status, skb);
2591
2592                         /* Stop after net poll weight */
2593                         if (++work_done >= to_do)
2594                                 goto exit_loop;
2595                         break;
2596
2597 #ifdef SKY2_VLAN_TAG_USED
2598                 case OP_RXVLAN:
2599                         sky2->rx_tag = length;
2600                         break;
2601
2602                 case OP_RXCHKSVLAN:
2603                         sky2->rx_tag = length;
2604                         /* fall through */
2605 #endif
2606                 case OP_RXCHKS:
2607                         if (likely(sky2->flags & SKY2_FLAG_RX_CHECKSUM))
2608                                 sky2_rx_checksum(sky2, status);
2609                         break;
2610
2611                 case OP_TXINDEXLE:
2612                         /* TX index reports status for both ports */
2613                         sky2_tx_done(hw->dev[0], status & 0xfff);
2614                         if (hw->dev[1])
2615                                 sky2_tx_done(hw->dev[1],
2616                                      ((status >> 24) & 0xff)
2617                                              | (u16)(length & 0xf) << 8);
2618                         break;
2619
2620                 default:
2621                         if (net_ratelimit())
2622                                 pr_warning("unknown status opcode 0x%x\n", opcode);
2623                 }
2624         } while (hw->st_idx != idx);
2625
2626         /* Fully processed status ring so clear irq */
2627         sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
2628
2629 exit_loop:
2630         sky2_rx_done(hw, 0, total_packets[0], total_bytes[0]);
2631         sky2_rx_done(hw, 1, total_packets[1], total_bytes[1]);
2632
2633         return work_done;
2634 }
2635
2636 static void sky2_hw_error(struct sky2_hw *hw, unsigned port, u32 status)
2637 {
2638         struct net_device *dev = hw->dev[port];
2639
2640         if (net_ratelimit())
2641                 netdev_info(dev, "hw error interrupt status 0x%x\n", status);
2642
2643         if (status & Y2_IS_PAR_RD1) {
2644                 if (net_ratelimit())
2645                         netdev_err(dev, "ram data read parity error\n");
2646                 /* Clear IRQ */
2647                 sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_RD_PERR);
2648         }
2649
2650         if (status & Y2_IS_PAR_WR1) {
2651                 if (net_ratelimit())
2652                         netdev_err(dev, "ram data write parity error\n");
2653
2654                 sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_WR_PERR);
2655         }
2656
2657         if (status & Y2_IS_PAR_MAC1) {
2658                 if (net_ratelimit())
2659                         netdev_err(dev, "MAC parity error\n");
2660                 sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_PE);
2661         }
2662
2663         if (status & Y2_IS_PAR_RX1) {
2664                 if (net_ratelimit())
2665                         netdev_err(dev, "RX parity error\n");
2666                 sky2_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), BMU_CLR_IRQ_PAR);
2667         }
2668
2669         if (status & Y2_IS_TCP_TXA1) {
2670                 if (net_ratelimit())
2671                         netdev_err(dev, "TCP segmentation error\n");
2672                 sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_CLR_IRQ_TCP);
2673         }
2674 }
2675
2676 static void sky2_hw_intr(struct sky2_hw *hw)
2677 {
2678         struct pci_dev *pdev = hw->pdev;
2679         u32 status = sky2_read32(hw, B0_HWE_ISRC);
2680         u32 hwmsk = sky2_read32(hw, B0_HWE_IMSK);
2681
2682         status &= hwmsk;
2683
2684         if (status & Y2_IS_TIST_OV)
2685                 sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
2686
2687         if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) {
2688                 u16 pci_err;
2689
2690                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2691                 pci_err = sky2_pci_read16(hw, PCI_STATUS);
2692                 if (net_ratelimit())
2693                         dev_err(&pdev->dev, "PCI hardware error (0x%x)\n",
2694                                 pci_err);
2695
2696                 sky2_pci_write16(hw, PCI_STATUS,
2697                                       pci_err | PCI_STATUS_ERROR_BITS);
2698                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2699         }
2700
2701         if (status & Y2_IS_PCI_EXP) {
2702                 /* PCI-Express uncorrectable Error occurred */
2703                 u32 err;
2704
2705                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2706                 err = sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
2707                 sky2_write32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS,
2708                              0xfffffffful);
2709                 if (net_ratelimit())
2710                         dev_err(&pdev->dev, "PCI Express error (0x%x)\n", err);
2711
2712                 sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
2713                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2714         }
2715
2716         if (status & Y2_HWE_L1_MASK)
2717                 sky2_hw_error(hw, 0, status);
2718         status >>= 8;
2719         if (status & Y2_HWE_L1_MASK)
2720                 sky2_hw_error(hw, 1, status);
2721 }
2722
2723 static void sky2_mac_intr(struct sky2_hw *hw, unsigned port)
2724 {
2725         struct net_device *dev = hw->dev[port];
2726         struct sky2_port *sky2 = netdev_priv(dev);
2727         u8 status = sky2_read8(hw, SK_REG(port, GMAC_IRQ_SRC));
2728
2729         netif_info(sky2, intr, dev, "mac interrupt status 0x%x\n", status);
2730
2731         if (status & GM_IS_RX_CO_OV)
2732                 gma_read16(hw, port, GM_RX_IRQ_SRC);
2733
2734         if (status & GM_IS_TX_CO_OV)
2735                 gma_read16(hw, port, GM_TX_IRQ_SRC);
2736
2737         if (status & GM_IS_RX_FF_OR) {
2738                 ++dev->stats.rx_fifo_errors;
2739                 sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_CLI_RX_FO);
2740         }
2741
2742         if (status & GM_IS_TX_FF_UR) {
2743                 ++dev->stats.tx_fifo_errors;
2744                 sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_FU);
2745         }
2746 }
2747
2748 /* This should never happen it is a bug. */
2749 static void sky2_le_error(struct sky2_hw *hw, unsigned port, u16 q)
2750 {
2751         struct net_device *dev = hw->dev[port];
2752         u16 idx = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX));
2753
2754         dev_err(&hw->pdev->dev, "%s: descriptor error q=%#x get=%u put=%u\n",
2755                 dev->name, (unsigned) q, (unsigned) idx,
2756                 (unsigned) sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX)));
2757
2758         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_IRQ_CHK);
2759 }
2760
2761 static int sky2_rx_hung(struct net_device *dev)
2762 {
2763         struct sky2_port *sky2 = netdev_priv(dev);
2764         struct sky2_hw *hw = sky2->hw;
2765         unsigned port = sky2->port;
2766         unsigned rxq = rxqaddr[port];
2767         u32 mac_rp = sky2_read32(hw, SK_REG(port, RX_GMF_RP));
2768         u8 mac_lev = sky2_read8(hw, SK_REG(port, RX_GMF_RLEV));
2769         u8 fifo_rp = sky2_read8(hw, Q_ADDR(rxq, Q_RP));
2770         u8 fifo_lev = sky2_read8(hw, Q_ADDR(rxq, Q_RL));
2771
2772         /* If idle and MAC or PCI is stuck */
2773         if (sky2->check.last == dev->last_rx &&
2774             ((mac_rp == sky2->check.mac_rp &&
2775               mac_lev != 0 && mac_lev >= sky2->check.mac_lev) ||
2776              /* Check if the PCI RX hang */
2777              (fifo_rp == sky2->check.fifo_rp &&
2778               fifo_lev != 0 && fifo_lev >= sky2->check.fifo_lev))) {
2779                 netdev_printk(KERN_DEBUG, dev,
2780                               "hung mac %d:%d fifo %d (%d:%d)\n",
2781                               mac_lev, mac_rp, fifo_lev,
2782                               fifo_rp, sky2_read8(hw, Q_ADDR(rxq, Q_WP)));
2783                 return 1;
2784         } else {
2785                 sky2->check.last = dev->last_rx;
2786                 sky2->check.mac_rp = mac_rp;
2787                 sky2->check.mac_lev = mac_lev;
2788                 sky2->check.fifo_rp = fifo_rp;
2789                 sky2->check.fifo_lev = fifo_lev;
2790                 return 0;
2791         }
2792 }
2793
2794 static void sky2_watchdog(unsigned long arg)
2795 {
2796         struct sky2_hw *hw = (struct sky2_hw *) arg;
2797
2798         /* Check for lost IRQ once a second */
2799         if (sky2_read32(hw, B0_ISRC)) {
2800                 napi_schedule(&hw->napi);
2801         } else {
2802                 int i, active = 0;
2803
2804                 for (i = 0; i < hw->ports; i++) {
2805                         struct net_device *dev = hw->dev[i];
2806                         if (!netif_running(dev))
2807                                 continue;
2808                         ++active;
2809
2810                         /* For chips with Rx FIFO, check if stuck */
2811                         if ((hw->flags & SKY2_HW_RAM_BUFFER) &&
2812                              sky2_rx_hung(dev)) {
2813                                 netdev_info(dev, "receiver hang detected\n");
2814                                 schedule_work(&hw->restart_work);
2815                                 return;
2816                         }
2817                 }
2818
2819                 if (active == 0)
2820                         return;
2821         }
2822
2823         mod_timer(&hw->watchdog_timer, round_jiffies(jiffies + HZ));
2824 }
2825
2826 /* Hardware/software error handling */
2827 static void sky2_err_intr(struct sky2_hw *hw, u32 status)
2828 {
2829         if (net_ratelimit())
2830                 dev_warn(&hw->pdev->dev, "error interrupt status=%#x\n", status);
2831
2832         if (status & Y2_IS_HW_ERR)
2833                 sky2_hw_intr(hw);
2834
2835         if (status & Y2_IS_IRQ_MAC1)
2836                 sky2_mac_intr(hw, 0);
2837
2838         if (status & Y2_IS_IRQ_MAC2)
2839                 sky2_mac_intr(hw, 1);
2840
2841         if (status & Y2_IS_CHK_RX1)
2842                 sky2_le_error(hw, 0, Q_R1);
2843
2844         if (status & Y2_IS_CHK_RX2)
2845                 sky2_le_error(hw, 1, Q_R2);
2846
2847         if (status & Y2_IS_CHK_TXA1)
2848                 sky2_le_error(hw, 0, Q_XA1);
2849
2850         if (status & Y2_IS_CHK_TXA2)
2851                 sky2_le_error(hw, 1, Q_XA2);
2852 }
2853
2854 static int sky2_poll(struct napi_struct *napi, int work_limit)
2855 {
2856         struct sky2_hw *hw = container_of(napi, struct sky2_hw, napi);
2857         u32 status = sky2_read32(hw, B0_Y2_SP_EISR);
2858         int work_done = 0;
2859         u16 idx;
2860
2861         if (unlikely(status & Y2_IS_ERROR))
2862                 sky2_err_intr(hw, status);
2863
2864         if (status & Y2_IS_IRQ_PHY1)
2865                 sky2_phy_intr(hw, 0);
2866
2867         if (status & Y2_IS_IRQ_PHY2)
2868                 sky2_phy_intr(hw, 1);
2869
2870         if (status & Y2_IS_PHY_QLNK)
2871                 sky2_qlink_intr(hw);
2872
2873         while ((idx = sky2_read16(hw, STAT_PUT_IDX)) != hw->st_idx) {
2874                 work_done += sky2_status_intr(hw, work_limit - work_done, idx);
2875
2876                 if (work_done >= work_limit)
2877                         goto done;
2878         }
2879
2880         napi_complete(napi);
2881         sky2_read32(hw, B0_Y2_SP_LISR);
2882 done:
2883
2884         return work_done;
2885 }
2886
2887 static irqreturn_t sky2_intr(int irq, void *dev_id)
2888 {
2889         struct sky2_hw *hw = dev_id;
2890         u32 status;
2891
2892         /* Reading this mask interrupts as side effect */
2893         status = sky2_read32(hw, B0_Y2_SP_ISRC2);
2894         if (status == 0 || status == ~0)
2895                 return IRQ_NONE;
2896
2897         prefetch(&hw->st_le[hw->st_idx]);
2898
2899         napi_schedule(&hw->napi);
2900
2901         return IRQ_HANDLED;
2902 }
2903
2904 #ifdef CONFIG_NET_POLL_CONTROLLER
2905 static void sky2_netpoll(struct net_device *dev)
2906 {
2907         struct sky2_port *sky2 = netdev_priv(dev);
2908
2909         napi_schedule(&sky2->hw->napi);
2910 }
2911 #endif
2912
2913 /* Chip internal frequency for clock calculations */
2914 static u32 sky2_mhz(const struct sky2_hw *hw)
2915 {
2916         switch (hw->chip_id) {
2917         case CHIP_ID_YUKON_EC:
2918         case CHIP_ID_YUKON_EC_U:
2919         case CHIP_ID_YUKON_EX:
2920         case CHIP_ID_YUKON_SUPR:
2921         case CHIP_ID_YUKON_UL_2:
2922         case CHIP_ID_YUKON_OPT:
2923                 return 125;
2924
2925         case CHIP_ID_YUKON_FE:
2926                 return 100;
2927
2928         case CHIP_ID_YUKON_FE_P:
2929                 return 50;
2930
2931         case CHIP_ID_YUKON_XL:
2932                 return 156;
2933
2934         default:
2935                 BUG();
2936         }
2937 }
2938
2939 static inline u32 sky2_us2clk(const struct sky2_hw *hw, u32 us)
2940 {
2941         return sky2_mhz(hw) * us;
2942 }
2943
2944 static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk)
2945 {
2946         return clk / sky2_mhz(hw);
2947 }
2948
2949
2950 static int __devinit sky2_init(struct sky2_hw *hw)
2951 {
2952         u8 t8;
2953
2954         /* Enable all clocks and check for bad PCI access */
2955         sky2_pci_write32(hw, PCI_DEV_REG3, 0);
2956
2957         sky2_write8(hw, B0_CTST, CS_RST_CLR);
2958
2959         hw->chip_id = sky2_read8(hw, B2_CHIP_ID);
2960         hw->chip_rev = (sky2_read8(hw, B2_MAC_CFG) & CFG_CHIP_R_MSK) >> 4;
2961
2962         switch(hw->chip_id) {
2963         case CHIP_ID_YUKON_XL:
2964                 hw->flags = SKY2_HW_GIGABIT | SKY2_HW_NEWER_PHY;
2965                 break;
2966
2967         case CHIP_ID_YUKON_EC_U:
2968                 hw->flags = SKY2_HW_GIGABIT
2969                         | SKY2_HW_NEWER_PHY
2970                         | SKY2_HW_ADV_POWER_CTL;
2971                 break;
2972
2973         case CHIP_ID_YUKON_EX:
2974                 hw->flags = SKY2_HW_GIGABIT
2975                         | SKY2_HW_NEWER_PHY
2976                         | SKY2_HW_NEW_LE
2977                         | SKY2_HW_ADV_POWER_CTL;
2978
2979                 /* New transmit checksum */
2980                 if (hw->chip_rev != CHIP_REV_YU_EX_B0)
2981                         hw->flags |= SKY2_HW_AUTO_TX_SUM;
2982                 break;
2983
2984         case CHIP_ID_YUKON_EC:
2985                 /* This rev is really old, and requires untested workarounds */
2986                 if (hw->chip_rev == CHIP_REV_YU_EC_A1) {
2987                         dev_err(&hw->pdev->dev, "unsupported revision Yukon-EC rev A1\n");
2988                         return -EOPNOTSUPP;
2989                 }
2990                 hw->flags = SKY2_HW_GIGABIT;
2991                 break;
2992
2993         case CHIP_ID_YUKON_FE:
2994                 break;
2995
2996         case CHIP_ID_YUKON_FE_P:
2997                 hw->flags = SKY2_HW_NEWER_PHY
2998                         | SKY2_HW_NEW_LE
2999                         | SKY2_HW_AUTO_TX_SUM
3000                         | SKY2_HW_ADV_POWER_CTL;
3001                 break;
3002
3003         case CHIP_ID_YUKON_SUPR:
3004                 hw->flags = SKY2_HW_GIGABIT
3005                         | SKY2_HW_NEWER_PHY
3006                         | SKY2_HW_NEW_LE
3007                         | SKY2_HW_AUTO_TX_SUM
3008                         | SKY2_HW_ADV_POWER_CTL;
3009                 break;
3010
3011         case CHIP_ID_YUKON_UL_2:
3012                 hw->flags = SKY2_HW_GIGABIT
3013                         | SKY2_HW_ADV_POWER_CTL;
3014                 break;
3015
3016         case CHIP_ID_YUKON_OPT:
3017                 hw->flags = SKY2_HW_GIGABIT
3018                         | SKY2_HW_NEW_LE
3019                         | SKY2_HW_ADV_POWER_CTL;
3020                 break;
3021
3022         default:
3023                 dev_err(&hw->pdev->dev, "unsupported chip type 0x%x\n",
3024                         hw->chip_id);
3025                 return -EOPNOTSUPP;
3026         }
3027
3028         hw->pmd_type = sky2_read8(hw, B2_PMD_TYP);
3029         if (hw->pmd_type == 'L' || hw->pmd_type == 'S' || hw->pmd_type == 'P')
3030                 hw->flags |= SKY2_HW_FIBRE_PHY;
3031
3032         hw->ports = 1;
3033         t8 = sky2_read8(hw, B2_Y2_HW_RES);
3034         if ((t8 & CFG_DUAL_MAC_MSK) == CFG_DUAL_MAC_MSK) {
3035                 if (!(sky2_read8(hw, B2_Y2_CLK_GATE) & Y2_STATUS_LNK2_INAC))
3036                         ++hw->ports;
3037         }
3038
3039         if (sky2_read8(hw, B2_E_0))
3040                 hw->flags |= SKY2_HW_RAM_BUFFER;
3041
3042         return 0;
3043 }
3044
3045 static void sky2_reset(struct sky2_hw *hw)
3046 {
3047         struct pci_dev *pdev = hw->pdev;
3048         u16 status;
3049         int i, cap;
3050         u32 hwe_mask = Y2_HWE_ALL_MASK;
3051
3052         /* disable ASF */
3053         if (hw->chip_id == CHIP_ID_YUKON_EX
3054             || hw->chip_id == CHIP_ID_YUKON_SUPR) {
3055                 sky2_write32(hw, CPU_WDOG, 0);
3056                 status = sky2_read16(hw, HCU_CCSR);
3057                 status &= ~(HCU_CCSR_AHB_RST | HCU_CCSR_CPU_RST_MODE |
3058                             HCU_CCSR_UC_STATE_MSK);
3059                 /*
3060                  * CPU clock divider shouldn't be used because
3061                  * - ASF firmware may malfunction
3062                  * - Yukon-Supreme: Parallel FLASH doesn't support divided clocks
3063                  */
3064                 status &= ~HCU_CCSR_CPU_CLK_DIVIDE_MSK;
3065                 sky2_write16(hw, HCU_CCSR, status);
3066                 sky2_write32(hw, CPU_WDOG, 0);
3067         } else
3068                 sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
3069         sky2_write16(hw, B0_CTST, Y2_ASF_DISABLE);
3070
3071         /* do a SW reset */
3072         sky2_write8(hw, B0_CTST, CS_RST_SET);
3073         sky2_write8(hw, B0_CTST, CS_RST_CLR);
3074
3075         /* allow writes to PCI config */
3076         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
3077
3078         /* clear PCI errors, if any */
3079         status = sky2_pci_read16(hw, PCI_STATUS);
3080         status |= PCI_STATUS_ERROR_BITS;
3081         sky2_pci_write16(hw, PCI_STATUS, status);
3082
3083         sky2_write8(hw, B0_CTST, CS_MRST_CLR);
3084
3085         cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
3086         if (cap) {
3087                 sky2_write32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS,
3088                              0xfffffffful);
3089
3090                 /* If error bit is stuck on ignore it */
3091                 if (sky2_read32(hw, B0_HWE_ISRC) & Y2_IS_PCI_EXP)
3092                         dev_info(&pdev->dev, "ignoring stuck error report bit\n");
3093                 else
3094                         hwe_mask |= Y2_IS_PCI_EXP;
3095         }
3096
3097         sky2_power_on(hw);
3098         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
3099
3100         for (i = 0; i < hw->ports; i++) {
3101                 sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET);
3102                 sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_CLR);
3103
3104                 if (hw->chip_id == CHIP_ID_YUKON_EX ||
3105                     hw->chip_id == CHIP_ID_YUKON_SUPR)
3106                         sky2_write16(hw, SK_REG(i, GMAC_CTRL),
3107                                      GMC_BYP_MACSECRX_ON | GMC_BYP_MACSECTX_ON
3108                                      | GMC_BYP_RETR_ON);
3109
3110         }
3111
3112         if (hw->chip_id == CHIP_ID_YUKON_SUPR && hw->chip_rev > CHIP_REV_YU_SU_B0) {
3113                 /* enable MACSec clock gating */
3114                 sky2_pci_write32(hw, PCI_DEV_REG3, P_CLK_MACSEC_DIS);
3115         }
3116
3117         if (hw->chip_id == CHIP_ID_YUKON_OPT) {
3118                 u16 reg;
3119                 u32 msk;
3120
3121                 if (hw->chip_rev == 0) {
3122                         /* disable PCI-E PHY power down (set PHY reg 0x80, bit 7 */
3123                         sky2_write32(hw, Y2_PEX_PHY_DATA, (0x80UL << 16) | (1 << 7));
3124
3125                         /* set PHY Link Detect Timer to 1.1 second (11x 100ms) */
3126                         reg = 10;
3127                 } else {
3128                         /* set PHY Link Detect Timer to 0.4 second (4x 100ms) */
3129                         reg = 3;
3130                 }
3131
3132                 reg <<= PSM_CONFIG_REG4_TIMER_PHY_LINK_DETECT_BASE;
3133
3134                 /* reset PHY Link Detect */
3135                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
3136                 sky2_pci_write16(hw, PSM_CONFIG_REG4,
3137                                  reg | PSM_CONFIG_REG4_RST_PHY_LINK_DETECT);
3138                 sky2_pci_write16(hw, PSM_CONFIG_REG4, reg);
3139
3140
3141                 /* enable PHY Quick Link */
3142                 msk = sky2_read32(hw, B0_IMSK);
3143                 msk |= Y2_IS_PHY_QLNK;
3144                 sky2_write32(hw, B0_IMSK, msk);
3145
3146                 /* check if PSMv2 was running before */
3147                 reg = sky2_pci_read16(hw, PSM_CONFIG_REG3);
3148                 if (reg & PCI_EXP_LNKCTL_ASPMC) {
3149                         cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
3150                         /* restore the PCIe Link Control register */
3151                         sky2_pci_write16(hw, cap + PCI_EXP_LNKCTL, reg);
3152                 }
3153                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
3154
3155                 /* re-enable PEX PM in PEX PHY debug reg. 8 (clear bit 12) */
3156                 sky2_write32(hw, Y2_PEX_PHY_DATA, PEX_DB_ACCESS | (0x08UL << 16));
3157         }
3158
3159         /* Clear I2C IRQ noise */
3160         sky2_write32(hw, B2_I2C_IRQ, 1);
3161
3162         /* turn off hardware timer (unused) */
3163         sky2_write8(hw, B2_TI_CTRL, TIM_STOP);
3164         sky2_write8(hw, B2_TI_CTRL, TIM_CLR_IRQ);
3165
3166         /* Turn off descriptor polling */
3167         sky2_write32(hw, B28_DPT_CTRL, DPT_STOP);
3168
3169         /* Turn off receive timestamp */
3170         sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_STOP);
3171         sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
3172
3173         /* enable the Tx Arbiters */
3174         for (i = 0; i < hw->ports; i++)
3175                 sky2_write8(hw, SK_REG(i, TXA_CTRL), TXA_ENA_ARB);
3176
3177         /* Initialize ram interface */
3178         for (i = 0; i < hw->ports; i++) {
3179                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_CTRL), RI_RST_CLR);
3180
3181                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R1), SK_RI_TO_53);
3182                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA1), SK_RI_TO_53);
3183                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS1), SK_RI_TO_53);
3184                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R1), SK_RI_TO_53);
3185                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA1), SK_RI_TO_53);
3186                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS1), SK_RI_TO_53);
3187                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R2), SK_RI_TO_53);
3188                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA2), SK_RI_TO_53);
3189                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS2), SK_RI_TO_53);
3190                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R2), SK_RI_TO_53);
3191                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA2), SK_RI_TO_53);
3192                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS2), SK_RI_TO_53);
3193         }
3194
3195         sky2_write32(hw, B0_HWE_IMSK, hwe_mask);
3196
3197         for (i = 0; i < hw->ports; i++)
3198                 sky2_gmac_reset(hw, i);
3199
3200         memset(hw->st_le, 0, STATUS_LE_BYTES);
3201         hw->st_idx = 0;
3202
3203         sky2_write32(hw, STAT_CTRL, SC_STAT_RST_SET);
3204         sky2_write32(hw, STAT_CTRL, SC_STAT_RST_CLR);
3205
3206         sky2_write32(hw, STAT_LIST_ADDR_LO, hw->st_dma);
3207         sky2_write32(hw, STAT_LIST_ADDR_HI, (u64) hw->st_dma >> 32);
3208
3209         /* Set the list last index */
3210         sky2_write16(hw, STAT_LAST_IDX, STATUS_RING_SIZE - 1);
3211
3212         sky2_write16(hw, STAT_TX_IDX_TH, 10);
3213         sky2_write8(hw, STAT_FIFO_WM, 16);
3214
3215         /* set Status-FIFO ISR watermark */
3216         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0)
3217                 sky2_write8(hw, STAT_FIFO_ISR_WM, 4);
3218         else
3219                 sky2_write8(hw, STAT_FIFO_ISR_WM, 16);
3220
3221         sky2_write32(hw, STAT_TX_TIMER_INI, sky2_us2clk(hw, 1000));
3222         sky2_write32(hw, STAT_ISR_TIMER_INI, sky2_us2clk(hw, 20));
3223         sky2_write32(hw, STAT_LEV_TIMER_INI, sky2_us2clk(hw, 100));
3224
3225         /* enable status unit */
3226         sky2_write32(hw, STAT_CTRL, SC_STAT_OP_ON);
3227
3228         sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
3229         sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START);
3230         sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
3231 }
3232
3233 /* Take device down (offline).
3234  * Equivalent to doing dev_stop() but this does not
3235  * inform upper layers of the transistion.
3236  */
3237 static void sky2_detach(struct net_device *dev)
3238 {
3239         if (netif_running(dev)) {
3240                 netif_tx_lock(dev);
3241                 netif_device_detach(dev);       /* stop txq */
3242                 netif_tx_unlock(dev);
3243                 sky2_down(dev);
3244         }
3245 }
3246
3247 /* Bring device back after doing sky2_detach */
3248 static int sky2_reattach(struct net_device *dev)
3249 {
3250         int err = 0;
3251
3252         if (netif_running(dev)) {
3253                 err = sky2_up(dev);
3254                 if (err) {
3255                         netdev_info(dev, "could not restart %d\n", err);
3256                         dev_close(dev);
3257                 } else {
3258                         netif_device_attach(dev);
3259                         sky2_set_multicast(dev);
3260                 }
3261         }
3262
3263         return err;
3264 }
3265
3266 static void sky2_restart(struct work_struct *work)
3267 {
3268         struct sky2_hw *hw = container_of(work, struct sky2_hw, restart_work);
3269         u32 imask;
3270         int i;
3271
3272         rtnl_lock();
3273
3274         napi_disable(&hw->napi);
3275         synchronize_irq(hw->pdev->irq);
3276         imask = sky2_read32(hw, B0_IMSK);
3277         sky2_write32(hw, B0_IMSK, 0);
3278
3279         for (i = 0; i < hw->ports; i++) {
3280                 struct net_device *dev = hw->dev[i];
3281                 struct sky2_port *sky2 = netdev_priv(dev);
3282
3283                 if (!netif_running(dev))
3284                         continue;
3285
3286                 netif_carrier_off(dev);
3287                 netif_tx_disable(dev);
3288                 sky2_hw_down(sky2);
3289         }
3290
3291         sky2_reset(hw);
3292
3293         for (i = 0; i < hw->ports; i++) {
3294                 struct net_device *dev = hw->dev[i];
3295                 struct sky2_port *sky2 = netdev_priv(dev);
3296
3297                 if (!netif_running(dev))
3298                         continue;
3299
3300                 sky2_hw_up(sky2);
3301                 netif_wake_queue(dev);
3302         }
3303
3304         sky2_write32(hw, B0_IMSK, imask);
3305         sky2_read32(hw, B0_IMSK);
3306
3307         sky2_read32(hw, B0_Y2_SP_LISR);
3308         napi_enable(&hw->napi);
3309
3310         rtnl_unlock();
3311 }
3312
3313 static inline u8 sky2_wol_supported(const struct sky2_hw *hw)
3314 {
3315         return sky2_is_copper(hw) ? (WAKE_PHY | WAKE_MAGIC) : 0;
3316 }
3317
3318 static void sky2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3319 {
3320         const struct sky2_port *sky2 = netdev_priv(dev);
3321
3322         wol->supported = sky2_wol_supported(sky2->hw);
3323         wol->wolopts = sky2->wol;
3324 }
3325
3326 static int sky2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3327 {
3328         struct sky2_port *sky2 = netdev_priv(dev);
3329         struct sky2_hw *hw = sky2->hw;
3330
3331         if ((wol->wolopts & ~sky2_wol_supported(sky2->hw)) ||
3332             !device_can_wakeup(&hw->pdev->dev))
3333                 return -EOPNOTSUPP;
3334
3335         sky2->wol = wol->wolopts;
3336         return 0;
3337 }
3338
3339 static u32 sky2_supported_modes(const struct sky2_hw *hw)
3340 {
3341         if (sky2_is_copper(hw)) {
3342                 u32 modes = SUPPORTED_10baseT_Half
3343                         | SUPPORTED_10baseT_Full
3344                         | SUPPORTED_100baseT_Half
3345                         | SUPPORTED_100baseT_Full
3346                         | SUPPORTED_Autoneg | SUPPORTED_TP;
3347
3348                 if (hw->flags & SKY2_HW_GIGABIT)
3349                         modes |= SUPPORTED_1000baseT_Half
3350                                 | SUPPORTED_1000baseT_Full;
3351                 return modes;
3352         } else
3353                 return  SUPPORTED_1000baseT_Half
3354                         | SUPPORTED_1000baseT_Full
3355                         | SUPPORTED_Autoneg
3356                         | SUPPORTED_FIBRE;
3357 }
3358
3359 static int sky2_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
3360 {
3361         struct sky2_port *sky2 = netdev_priv(dev);
3362         struct sky2_hw *hw = sky2->hw;
3363
3364         ecmd->transceiver = XCVR_INTERNAL;
3365         ecmd->supported = sky2_supported_modes(hw);
3366         ecmd->phy_address = PHY_ADDR_MARV;
3367         if (sky2_is_copper(hw)) {
3368                 ecmd->port = PORT_TP;
3369                 ecmd->speed = sky2->speed;
3370         } else {
3371                 ecmd->speed = SPEED_1000;
3372                 ecmd->port = PORT_FIBRE;
3373         }
3374
3375         ecmd->advertising = sky2->advertising;
3376         ecmd->autoneg = (sky2->flags & SKY2_FLAG_AUTO_SPEED)
3377                 ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3378         ecmd->duplex = sky2->duplex;
3379         return 0;
3380 }
3381
3382 static int sky2_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
3383 {
3384         struct sky2_port *sky2 = netdev_priv(dev);
3385         const struct sky2_hw *hw = sky2->hw;
3386         u32 supported = sky2_supported_modes(hw);
3387
3388         if (ecmd->autoneg == AUTONEG_ENABLE) {
3389                 sky2->flags |= SKY2_FLAG_AUTO_SPEED;
3390                 ecmd->advertising = supported;
3391                 sky2->duplex = -1;
3392                 sky2->speed = -1;
3393         } else {
3394                 u32 setting;
3395
3396                 switch (ecmd->speed) {
3397                 case SPEED_1000:
3398                         if (ecmd->duplex == DUPLEX_FULL)
3399                                 setting = SUPPORTED_1000baseT_Full;
3400                         else if (ecmd->duplex == DUPLEX_HALF)
3401                                 setting = SUPPORTED_1000baseT_Half;
3402                         else
3403                                 return -EINVAL;
3404                         break;
3405                 case SPEED_100:
3406                         if (ecmd->duplex == DUPLEX_FULL)
3407                                 setting = SUPPORTED_100baseT_Full;
3408                         else if (ecmd->duplex == DUPLEX_HALF)
3409                                 setting = SUPPORTED_100baseT_Half;
3410                         else
3411                                 return -EINVAL;
3412                         break;
3413
3414                 case SPEED_10:
3415                         if (ecmd->duplex == DUPLEX_FULL)
3416                                 setting = SUPPORTED_10baseT_Full;
3417                         else if (ecmd->duplex == DUPLEX_HALF)
3418                                 setting = SUPPORTED_10baseT_Half;
3419                         else
3420                                 return -EINVAL;
3421                         break;
3422                 default:
3423                         return -EINVAL;
3424                 }
3425
3426                 if ((setting & supported) == 0)
3427                         return -EINVAL;
3428
3429                 sky2->speed = ecmd->speed;
3430                 sky2->duplex = ecmd->duplex;
3431                 sky2->flags &= ~SKY2_FLAG_AUTO_SPEED;
3432         }
3433
3434         sky2->advertising = ecmd->advertising;
3435
3436         if (netif_running(dev)) {
3437                 sky2_phy_reinit(sky2);
3438                 sky2_set_multicast(dev);
3439         }
3440
3441         return 0;
3442 }
3443
3444 static void sky2_get_drvinfo(struct net_device *dev,
3445                              struct ethtool_drvinfo *info)
3446 {
3447         struct sky2_port *sky2 = netdev_priv(dev);
3448
3449         strcpy(info->driver, DRV_NAME);
3450         strcpy(info->version, DRV_VERSION);
3451         strcpy(info->fw_version, "N/A");
3452         strcpy(info->bus_info, pci_name(sky2->hw->pdev));
3453 }
3454
3455 static const struct sky2_stat {
3456         char name[ETH_GSTRING_LEN];
3457         u16 offset;
3458 } sky2_stats[] = {
3459         { "tx_bytes",      GM_TXO_OK_HI },
3460         { "rx_bytes",      GM_RXO_OK_HI },
3461         { "tx_broadcast",  GM_TXF_BC_OK },
3462         { "rx_broadcast",  GM_RXF_BC_OK },
3463         { "tx_multicast",  GM_TXF_MC_OK },
3464         { "rx_multicast",  GM_RXF_MC_OK },
3465         { "tx_unicast",    GM_TXF_UC_OK },
3466         { "rx_unicast",    GM_RXF_UC_OK },
3467         { "tx_mac_pause",  GM_TXF_MPAUSE },
3468         { "rx_mac_pause",  GM_RXF_MPAUSE },
3469         { "collisions",    GM_TXF_COL },
3470         { "late_collision",GM_TXF_LAT_COL },
3471         { "aborted",       GM_TXF_ABO_COL },
3472         { "single_collisions", GM_TXF_SNG_COL },
3473         { "multi_collisions", GM_TXF_MUL_COL },
3474
3475         { "rx_short",      GM_RXF_SHT },
3476         { "rx_runt",       GM_RXE_FRAG },
3477         { "rx_64_byte_packets", GM_RXF_64B },
3478         { "rx_65_to_127_byte_packets", GM_RXF_127B },
3479         { "rx_128_to_255_byte_packets", GM_RXF_255B },
3480         { "rx_256_to_511_byte_packets", GM_RXF_511B },
3481         { "rx_512_to_1023_byte_packets", GM_RXF_1023B },
3482         { "rx_1024_to_1518_byte_packets", GM_RXF_1518B },
3483         { "rx_1518_to_max_byte_packets", GM_RXF_MAX_SZ },
3484         { "rx_too_long",   GM_RXF_LNG_ERR },
3485         { "rx_fifo_overflow", GM_RXE_FIFO_OV },
3486         { "rx_jabber",     GM_RXF_JAB_PKT },
3487         { "rx_fcs_error",   GM_RXF_FCS_ERR },
3488
3489         { "tx_64_byte_packets", GM_TXF_64B },
3490         { "tx_65_to_127_byte_packets", GM_TXF_127B },
3491         { "tx_128_to_255_byte_packets", GM_TXF_255B },
3492         { "tx_256_to_511_byte_packets", GM_TXF_511B },
3493         { "tx_512_to_1023_byte_packets", GM_TXF_1023B },
3494         { "tx_1024_to_1518_byte_packets", GM_TXF_1518B },
3495         { "tx_1519_to_max_byte_packets", GM_TXF_MAX_SZ },
3496         { "tx_fifo_underrun", GM_TXE_FIFO_UR },
3497 };
3498
3499 static u32 sky2_get_rx_csum(struct net_device *dev)
3500 {
3501         struct sky2_port *sky2 = netdev_priv(dev);
3502
3503         return !!(sky2->flags & SKY2_FLAG_RX_CHECKSUM);
3504 }
3505
3506 static int sky2_set_rx_csum(struct net_device *dev, u32 data)
3507 {
3508         struct sky2_port *sky2 = netdev_priv(dev);
3509
3510         if (data)
3511                 sky2->flags |= SKY2_FLAG_RX_CHECKSUM;
3512         else
3513                 sky2->flags &= ~SKY2_FLAG_RX_CHECKSUM;
3514
3515         sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
3516                      data ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM);
3517
3518         return 0;
3519 }
3520
3521 static u32 sky2_get_msglevel(struct net_device *netdev)
3522 {
3523         struct sky2_port *sky2 = netdev_priv(netdev);
3524         return sky2->msg_enable;
3525 }
3526
3527 static int sky2_nway_reset(struct net_device *dev)
3528 {
3529         struct sky2_port *sky2 = netdev_priv(dev);
3530
3531         if (!netif_running(dev) || !(sky2->flags & SKY2_FLAG_AUTO_SPEED))
3532                 return -EINVAL;
3533
3534         sky2_phy_reinit(sky2);
3535         sky2_set_multicast(dev);
3536
3537         return 0;
3538 }
3539
3540 static void sky2_phy_stats(struct sky2_port *sky2, u64 * data, unsigned count)
3541 {
3542         struct sky2_hw *hw = sky2->hw;
3543         unsigned port = sky2->port;
3544         int i;
3545
3546         data[0] = (u64) gma_read32(hw, port, GM_TXO_OK_HI) << 32
3547             | (u64) gma_read32(hw, port, GM_TXO_OK_LO);
3548         data[1] = (u64) gma_read32(hw, port, GM_RXO_OK_HI) << 32
3549             | (u64) gma_read32(hw, port, GM_RXO_OK_LO);
3550
3551         for (i = 2; i < count; i++)
3552                 data[i] = (u64) gma_read32(hw, port, sky2_stats[i].offset);
3553 }
3554
3555 static void sky2_set_msglevel(struct net_device *netdev, u32 value)
3556 {
3557         struct sky2_port *sky2 = netdev_priv(netdev);
3558         sky2->msg_enable = value;
3559 }
3560
3561 static int sky2_get_sset_count(struct net_device *dev, int sset)
3562 {
3563         switch (sset) {
3564         case ETH_SS_STATS:
3565                 return ARRAY_SIZE(sky2_stats);
3566         default:
3567                 return -EOPNOTSUPP;
3568         }
3569 }
3570
3571 static void sky2_get_ethtool_stats(struct net_device *dev,
3572                                    struct ethtool_stats *stats, u64 * data)
3573 {
3574         struct sky2_port *sky2 = netdev_priv(dev);
3575
3576         sky2_phy_stats(sky2, data, ARRAY_SIZE(sky2_stats));
3577 }
3578
3579 static void sky2_get_strings(struct net_device *dev, u32 stringset, u8 * data)
3580 {
3581         int i;
3582
3583         switch (stringset) {
3584         case ETH_SS_STATS:
3585                 for (i = 0; i < ARRAY_SIZE(sky2_stats); i++)
3586                         memcpy(data + i * ETH_GSTRING_LEN,
3587                                sky2_stats[i].name, ETH_GSTRING_LEN);
3588                 break;
3589         }
3590 }
3591
3592 static int sky2_set_mac_address(struct net_device *dev, void *p)
3593 {
3594         struct sky2_port *sky2 = netdev_priv(dev);
3595         struct sky2_hw *hw = sky2->hw;
3596         unsigned port = sky2->port;
3597         const struct sockaddr *addr = p;
3598
3599         if (!is_valid_ether_addr(addr->sa_data))
3600                 return -EADDRNOTAVAIL;
3601
3602         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3603         memcpy_toio(hw->regs + B2_MAC_1 + port * 8,
3604                     dev->dev_addr, ETH_ALEN);
3605         memcpy_toio(hw->regs + B2_MAC_2 + port * 8,
3606                     dev->dev_addr, ETH_ALEN);
3607
3608         /* virtual address for data */
3609         gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
3610
3611         /* physical address: used for pause frames */
3612         gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
3613
3614         return 0;
3615 }
3616
3617 static void inline sky2_add_filter(u8 filter[8], const u8 *addr)
3618 {
3619         u32 bit;
3620
3621         bit = ether_crc(ETH_ALEN, addr) & 63;
3622         filter[bit >> 3] |= 1 << (bit & 7);
3623 }
3624
3625 static void sky2_set_multicast(struct net_device *dev)
3626 {
3627         struct sky2_port *sky2 = netdev_priv(dev);
3628         struct sky2_hw *hw = sky2->hw;
3629         unsigned port = sky2->port;
3630         struct dev_mc_list *list;
3631         u16 reg;
3632         u8 filter[8];
3633         int rx_pause;
3634         static const u8 pause_mc_addr[ETH_ALEN] = { 0x1, 0x80, 0xc2, 0x0, 0x0, 0x1 };
3635
3636         rx_pause = (sky2->flow_status == FC_RX || sky2->flow_status == FC_BOTH);
3637         memset(filter, 0, sizeof(filter));
3638
3639         reg = gma_read16(hw, port, GM_RX_CTRL);
3640         reg |= GM_RXCR_UCF_ENA;
3641
3642         if (dev->flags & IFF_PROMISC)   /* promiscuous */
3643                 reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
3644         else if (dev->flags & IFF_ALLMULTI)
3645                 memset(filter, 0xff, sizeof(filter));
3646         else if (netdev_mc_empty(dev) && !rx_pause)
3647                 reg &= ~GM_RXCR_MCF_ENA;
3648         else {
3649                 reg |= GM_RXCR_MCF_ENA;
3650
3651                 if (rx_pause)
3652                         sky2_add_filter(filter, pause_mc_addr);
3653
3654                 netdev_for_each_mc_addr(list, dev)
3655                         sky2_add_filter(filter, list->dmi_addr);
3656         }
3657
3658         gma_write16(hw, port, GM_MC_ADDR_H1,
3659                     (u16) filter[0] | ((u16) filter[1] << 8));
3660         gma_write16(hw, port, GM_MC_ADDR_H2,
3661                     (u16) filter[2] | ((u16) filter[3] << 8));
3662         gma_write16(hw, port, GM_MC_ADDR_H3,
3663                     (u16) filter[4] | ((u16) filter[5] << 8));
3664         gma_write16(hw, port, GM_MC_ADDR_H4,
3665                     (u16) filter[6] | ((u16) filter[7] << 8));
3666
3667         gma_write16(hw, port, GM_RX_CTRL, reg);
3668 }
3669
3670 /* Can have one global because blinking is controlled by
3671  * ethtool and that is always under RTNL mutex
3672  */
3673 static void sky2_led(struct sky2_port *sky2, enum led_mode mode)
3674 {
3675         struct sky2_hw *hw = sky2->hw;
3676         unsigned port = sky2->port;
3677
3678         spin_lock_bh(&sky2->phy_lock);
3679         if (hw->chip_id == CHIP_ID_YUKON_EC_U ||
3680             hw->chip_id == CHIP_ID_YUKON_EX ||
3681             hw->chip_id == CHIP_ID_YUKON_SUPR) {
3682                 u16 pg;
3683                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
3684                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
3685
3686                 switch (mode) {
3687                 case MO_LED_OFF:
3688                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
3689                                      PHY_M_LEDC_LOS_CTRL(8) |
3690                                      PHY_M_LEDC_INIT_CTRL(8) |
3691                                      PHY_M_LEDC_STA1_CTRL(8) |
3692                                      PHY_M_LEDC_STA0_CTRL(8));
3693                         break;
3694                 case MO_LED_ON:
3695                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
3696                                      PHY_M_LEDC_LOS_CTRL(9) |
3697                                      PHY_M_LEDC_INIT_CTRL(9) |
3698                                      PHY_M_LEDC_STA1_CTRL(9) |
3699                                      PHY_M_LEDC_STA0_CTRL(9));
3700                         break;
3701                 case MO_LED_BLINK:
3702                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
3703                                      PHY_M_LEDC_LOS_CTRL(0xa) |
3704                                      PHY_M_LEDC_INIT_CTRL(0xa) |
3705                                      PHY_M_LEDC_STA1_CTRL(0xa) |
3706                                      PHY_M_LEDC_STA0_CTRL(0xa));
3707                         break;
3708                 case MO_LED_NORM:
3709                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
3710                                      PHY_M_LEDC_LOS_CTRL(1) |
3711                                      PHY_M_LEDC_INIT_CTRL(8) |
3712                                      PHY_M_LEDC_STA1_CTRL(7) |
3713                                      PHY_M_LEDC_STA0_CTRL(7));
3714                 }
3715
3716                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
3717         } else
3718                 gm_phy_write(hw, port, PHY_MARV_LED_OVER,
3719                                      PHY_M_LED_MO_DUP(mode) |
3720                                      PHY_M_LED_MO_10(mode) |
3721                                      PHY_M_LED_MO_100(mode) |
3722                                      PHY_M_LED_MO_1000(mode) |
3723                                      PHY_M_LED_MO_RX(mode) |
3724                                      PHY_M_LED_MO_TX(mode));
3725
3726         spin_unlock_bh(&sky2->phy_lock);
3727 }
3728
3729 /* blink LED's for finding board */
3730 static int sky2_phys_id(struct net_device *dev, u32 data)
3731 {
3732         struct sky2_port *sky2 = netdev_priv(dev);
3733         unsigned int i;
3734
3735         if (data == 0)
3736                 data = UINT_MAX;
3737
3738         for (i = 0; i < data; i++) {
3739                 sky2_led(sky2, MO_LED_ON);
3740                 if (msleep_interruptible(500))
3741                         break;
3742                 sky2_led(sky2, MO_LED_OFF);
3743                 if (msleep_interruptible(500))
3744                         break;
3745         }
3746         sky2_led(sky2, MO_LED_NORM);
3747
3748         return 0;
3749 }
3750
3751 static void sky2_get_pauseparam(struct net_device *dev,
3752                                 struct ethtool_pauseparam *ecmd)
3753 {
3754         struct sky2_port *sky2 = netdev_priv(dev);
3755
3756         switch (sky2->flow_mode) {
3757         case FC_NONE:
3758                 ecmd->tx_pause = ecmd->rx_pause = 0;
3759                 break;
3760         case FC_TX:
3761                 ecmd->tx_pause = 1, ecmd->rx_pause = 0;
3762                 break;
3763         case FC_RX:
3764                 ecmd->tx_pause = 0, ecmd->rx_pause = 1;
3765                 break;
3766         case FC_BOTH:
3767                 ecmd->tx_pause = ecmd->rx_pause = 1;
3768         }
3769
3770         ecmd->autoneg = (sky2->flags & SKY2_FLAG_AUTO_PAUSE)
3771                 ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3772 }
3773
3774 static int sky2_set_pauseparam(struct net_device *dev,
3775                                struct ethtool_pauseparam *ecmd)
3776 {
3777         struct sky2_port *sky2 = netdev_priv(dev);
3778
3779         if (ecmd->autoneg == AUTONEG_ENABLE)
3780                 sky2->flags |= SKY2_FLAG_AUTO_PAUSE;
3781         else
3782                 sky2->flags &= ~SKY2_FLAG_AUTO_PAUSE;
3783
3784         sky2->flow_mode = sky2_flow(ecmd->rx_pause, ecmd->tx_pause);
3785
3786         if (netif_running(dev))
3787                 sky2_phy_reinit(sky2);
3788
3789         return 0;
3790 }
3791
3792 static int sky2_get_coalesce(struct net_device *dev,
3793                              struct ethtool_coalesce *ecmd)
3794 {
3795         struct sky2_port *sky2 = netdev_priv(dev);
3796         struct sky2_hw *hw = sky2->hw;
3797
3798         if (sky2_read8(hw, STAT_TX_TIMER_CTRL) == TIM_STOP)
3799                 ecmd->tx_coalesce_usecs = 0;
3800         else {
3801                 u32 clks = sky2_read32(hw, STAT_TX_TIMER_INI);
3802                 ecmd->tx_coalesce_usecs = sky2_clk2us(hw, clks);
3803         }
3804         ecmd->tx_max_coalesced_frames = sky2_read16(hw, STAT_TX_IDX_TH);
3805
3806         if (sky2_read8(hw, STAT_LEV_TIMER_CTRL) == TIM_STOP)
3807                 ecmd->rx_coalesce_usecs = 0;
3808         else {
3809                 u32 clks = sky2_read32(hw, STAT_LEV_TIMER_INI);
3810                 ecmd->rx_coalesce_usecs = sky2_clk2us(hw, clks);
3811         }
3812         ecmd->rx_max_coalesced_frames = sky2_read8(hw, STAT_FIFO_WM);
3813
3814         if (sky2_read8(hw, STAT_ISR_TIMER_CTRL) == TIM_STOP)
3815                 ecmd->rx_coalesce_usecs_irq = 0;
3816         else {
3817                 u32 clks = sky2_read32(hw, STAT_ISR_TIMER_INI);
3818                 ecmd->rx_coalesce_usecs_irq = sky2_clk2us(hw, clks);
3819         }
3820
3821         ecmd->rx_max_coalesced_frames_irq = sky2_read8(hw, STAT_FIFO_ISR_WM);
3822
3823         return 0;
3824 }
3825
3826 /* Note: this affect both ports */
3827 static int sky2_set_coalesce(struct net_device *dev,
3828                              struct ethtool_coalesce *ecmd)
3829 {
3830         struct sky2_port *sky2 = netdev_priv(dev);
3831         struct sky2_hw *hw = sky2->hw;
3832         const u32 tmax = sky2_clk2us(hw, 0x0ffffff);
3833
3834         if (ecmd->tx_coalesce_usecs > tmax ||
3835             ecmd->rx_coalesce_usecs > tmax ||
3836             ecmd->rx_coalesce_usecs_irq > tmax)
3837                 return -EINVAL;
3838
3839         if (ecmd->tx_max_coalesced_frames >= sky2->tx_ring_size-1)
3840                 return -EINVAL;
3841         if (ecmd->rx_max_coalesced_frames > RX_MAX_PENDING)
3842                 return -EINVAL;
3843         if (ecmd->rx_max_coalesced_frames_irq >RX_MAX_PENDING)
3844                 return -EINVAL;
3845
3846         if (ecmd->tx_coalesce_usecs == 0)
3847                 sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
3848         else {
3849                 sky2_write32(hw, STAT_TX_TIMER_INI,
3850                              sky2_us2clk(hw, ecmd->tx_coalesce_usecs));
3851                 sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
3852         }
3853         sky2_write16(hw, STAT_TX_IDX_TH, ecmd->tx_max_coalesced_frames);
3854
3855         if (ecmd->rx_coalesce_usecs == 0)
3856                 sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_STOP);
3857         else {
3858                 sky2_write32(hw, STAT_LEV_TIMER_INI,
3859                              sky2_us2clk(hw, ecmd->rx_coalesce_usecs));
3860                 sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START);
3861         }
3862         sky2_write8(hw, STAT_FIFO_WM, ecmd->rx_max_coalesced_frames);
3863
3864         if (ecmd->rx_coalesce_usecs_irq == 0)
3865                 sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_STOP);
3866         else {
3867                 sky2_write32(hw, STAT_ISR_TIMER_INI,
3868                              sky2_us2clk(hw, ecmd->rx_coalesce_usecs_irq));
3869                 sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
3870         }
3871         sky2_write8(hw, STAT_FIFO_ISR_WM, ecmd->rx_max_coalesced_frames_irq);
3872         return 0;
3873 }
3874
3875 static void sky2_get_ringparam(struct net_device *dev,
3876                                struct ethtool_ringparam *ering)
3877 {
3878         struct sky2_port *sky2 = netdev_priv(dev);
3879
3880         ering->rx_max_pending = RX_MAX_PENDING;
3881         ering->rx_mini_max_pending = 0;
3882         ering->rx_jumbo_max_pending = 0;
3883         ering->tx_max_pending = TX_MAX_PENDING;
3884
3885         ering->rx_pending = sky2->rx_pending;
3886         ering->rx_mini_pending = 0;
3887         ering->rx_jumbo_pending = 0;
3888         ering->tx_pending = sky2->tx_pending;
3889 }
3890
3891 static int sky2_set_ringparam(struct net_device *dev,
3892                               struct ethtool_ringparam *ering)
3893 {
3894         struct sky2_port *sky2 = netdev_priv(dev);
3895
3896         if (ering->rx_pending > RX_MAX_PENDING ||
3897             ering->rx_pending < 8 ||
3898             ering->tx_pending < TX_MIN_PENDING ||
3899             ering->tx_pending > TX_MAX_PENDING)
3900                 return -EINVAL;
3901
3902         sky2_detach(dev);
3903
3904         sky2->rx_pending = ering->rx_pending;
3905         sky2->tx_pending = ering->tx_pending;
3906         sky2->tx_ring_size = roundup_pow_of_two(sky2->tx_pending+1);
3907
3908         return sky2_reattach(dev);
3909 }
3910
3911 static int sky2_get_regs_len(struct net_device *dev)
3912 {
3913         return 0x4000;
3914 }
3915
3916 static int sky2_reg_access_ok(struct sky2_hw *hw, unsigned int b)
3917 {
3918         /* This complicated switch statement is to make sure and
3919          * only access regions that are unreserved.
3920          * Some blocks are only valid on dual port cards.
3921          */
3922         switch (b) {
3923         /* second port */
3924         case 5:         /* Tx Arbiter 2 */
3925         case 9:         /* RX2 */
3926         case 14 ... 15: /* TX2 */
3927         case 17: case 19: /* Ram Buffer 2 */
3928         case 22 ... 23: /* Tx Ram Buffer 2 */
3929         case 25:        /* Rx MAC Fifo 1 */
3930         case 27:        /* Tx MAC Fifo 2 */
3931         case 31:        /* GPHY 2 */
3932         case 40 ... 47: /* Pattern Ram 2 */
3933         case 52: case 54: /* TCP Segmentation 2 */
3934         case 112 ... 116: /* GMAC 2 */
3935                 return hw->ports > 1;
3936
3937         case 0:         /* Control */
3938         case 2:         /* Mac address */
3939         case 4:         /* Tx Arbiter 1 */
3940         case 7:         /* PCI express reg */
3941         case 8:         /* RX1 */
3942         case 12 ... 13: /* TX1 */
3943         case 16: case 18:/* Rx Ram Buffer 1 */
3944         case 20 ... 21: /* Tx Ram Buffer 1 */
3945         case 24:        /* Rx MAC Fifo 1 */
3946         case 26:        /* Tx MAC Fifo 1 */
3947         case 28 ... 29: /* Descriptor and status unit */
3948         case 30:        /* GPHY 1*/
3949         case 32 ... 39: /* Pattern Ram 1 */
3950         case 48: case 50: /* TCP Segmentation 1 */
3951         case 56 ... 60: /* PCI space */
3952         case 80 ... 84: /* GMAC 1 */
3953                 return 1;
3954
3955         default:
3956                 return 0;
3957         }
3958 }
3959
3960 /*
3961  * Returns copy of control register region
3962  * Note: ethtool_get_regs always provides full size (16k) buffer
3963  */
3964 static void sky2_get_regs(struct net_device *dev, struct ethtool_regs *regs,
3965                           void *p)
3966 {
3967         const struct sky2_port *sky2 = netdev_priv(dev);
3968         const void __iomem *io = sky2->hw->regs;
3969         unsigned int b;
3970
3971         regs->version = 1;
3972
3973         for (b = 0; b < 128; b++) {
3974                 /* skip poisonous diagnostic ram region in block 3 */
3975                 if (b == 3)
3976                         memcpy_fromio(p + 0x10, io + 0x10, 128 - 0x10);
3977                 else if (sky2_reg_access_ok(sky2->hw, b))
3978                         memcpy_fromio(p, io, 128);
3979                 else
3980                         memset(p, 0, 128);
3981
3982                 p += 128;
3983                 io += 128;
3984         }
3985 }
3986
3987 /* In order to do Jumbo packets on these chips, need to turn off the
3988  * transmit store/forward. Therefore checksum offload won't work.
3989  */
3990 static int no_tx_offload(struct net_device *dev)
3991 {
3992         const struct sky2_port *sky2 = netdev_priv(dev);
3993         const struct sky2_hw *hw = sky2->hw;
3994
3995         return dev->mtu > ETH_DATA_LEN && hw->chip_id == CHIP_ID_YUKON_EC_U;
3996 }
3997
3998 static int sky2_set_tx_csum(struct net_device *dev, u32 data)
3999 {
4000         if (data && no_tx_offload(dev))
4001                 return -EINVAL;
4002
4003         return ethtool_op_set_tx_csum(dev, data);
4004 }
4005
4006
4007 static int sky2_set_tso(struct net_device *dev, u32 data)
4008 {
4009         if (data && no_tx_offload(dev))
4010                 return -EINVAL;
4011
4012         return ethtool_op_set_tso(dev, data);
4013 }
4014
4015 static int sky2_get_eeprom_len(struct net_device *dev)
4016 {
4017         struct sky2_port *sky2 = netdev_priv(dev);
4018         struct sky2_hw *hw = sky2->hw;
4019         u16 reg2;
4020
4021         reg2 = sky2_pci_read16(hw, PCI_DEV_REG2);
4022         return 1 << ( ((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
4023 }
4024
4025 static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy)
4026 {
4027         unsigned long start = jiffies;
4028
4029         while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) {
4030                 /* Can take up to 10.6 ms for write */
4031                 if (time_after(jiffies, start + HZ/4)) {
4032                         dev_err(&hw->pdev->dev, "VPD cycle timed out\n");
4033                         return -ETIMEDOUT;
4034                 }
4035                 mdelay(1);
4036         }
4037
4038         return 0;
4039 }
4040
4041 static int sky2_vpd_read(struct sky2_hw *hw, int cap, void *data,
4042                          u16 offset, size_t length)
4043 {
4044         int rc = 0;
4045
4046         while (length > 0) {
4047                 u32 val;
4048
4049                 sky2_pci_write16(hw, cap + PCI_VPD_ADDR, offset);
4050                 rc = sky2_vpd_wait(hw, cap, 0);
4051                 if (rc)
4052                         break;
4053
4054                 val = sky2_pci_read32(hw, cap + PCI_VPD_DATA);
4055
4056                 memcpy(data, &val, min(sizeof(val), length));
4057                 offset += sizeof(u32);
4058                 data += sizeof(u32);
4059                 length -= sizeof(u32);
4060         }
4061
4062         return rc;
4063 }
4064
4065 static int sky2_vpd_write(struct sky2_hw *hw, int cap, const void *data,
4066                           u16 offset, unsigned int length)
4067 {
4068         unsigned int i;
4069         int rc = 0;
4070
4071         for (i = 0; i < length; i += sizeof(u32)) {
4072                 u32 val = *(u32 *)(data + i);
4073
4074                 sky2_pci_write32(hw, cap + PCI_VPD_DATA, val);
4075                 sky2_pci_write32(hw, cap + PCI_VPD_ADDR, offset | PCI_VPD_ADDR_F);
4076
4077                 rc = sky2_vpd_wait(hw, cap, PCI_VPD_ADDR_F);
4078                 if (rc)
4079                         break;
4080         }
4081         return rc;
4082 }
4083
4084 static int sky2_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
4085                            u8 *data)
4086 {
4087         struct sky2_port *sky2 = netdev_priv(dev);
4088         int cap = pci_find_capability(sky2->hw->pdev, PCI_CAP_ID_VPD);
4089
4090         if (!cap)
4091                 return -EINVAL;
4092
4093         eeprom->magic = SKY2_EEPROM_MAGIC;
4094
4095         return sky2_vpd_read(sky2->hw, cap, data, eeprom->offset, eeprom->len);
4096 }
4097
4098 static int sky2_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
4099                            u8 *data)
4100 {
4101         struct sky2_port *sky2 = netdev_priv(dev);
4102         int cap = pci_find_capability(sky2->hw->pdev, PCI_CAP_ID_VPD);
4103
4104         if (!cap)
4105                 return -EINVAL;
4106
4107         if (eeprom->magic != SKY2_EEPROM_MAGIC)
4108                 return -EINVAL;
4109
4110         /* Partial writes not supported */
4111         if ((eeprom->offset & 3) || (eeprom->len & 3))
4112                 return -EINVAL;
4113
4114         return sky2_vpd_write(sky2->hw, cap, data, eeprom->offset, eeprom->len);
4115 }
4116
4117
4118 static const struct ethtool_ops sky2_ethtool_ops = {
4119         .get_settings   = sky2_get_settings,
4120         .set_settings   = sky2_set_settings,
4121         .get_drvinfo    = sky2_get_drvinfo,
4122         .get_wol        = sky2_get_wol,
4123         .set_wol        = sky2_set_wol,
4124         .get_msglevel   = sky2_get_msglevel,
4125         .set_msglevel   = sky2_set_msglevel,
4126         .nway_reset     = sky2_nway_reset,
4127         .get_regs_len   = sky2_get_regs_len,
4128         .get_regs       = sky2_get_regs,
4129         .get_link       = ethtool_op_get_link,
4130         .get_eeprom_len = sky2_get_eeprom_len,
4131         .get_eeprom     = sky2_get_eeprom,
4132         .set_eeprom     = sky2_set_eeprom,
4133         .set_sg         = ethtool_op_set_sg,
4134         .set_tx_csum    = sky2_set_tx_csum,
4135         .set_tso        = sky2_set_tso,
4136         .get_rx_csum    = sky2_get_rx_csum,
4137         .set_rx_csum    = sky2_set_rx_csum,
4138         .get_strings    = sky2_get_strings,
4139         .get_coalesce   = sky2_get_coalesce,
4140         .set_coalesce   = sky2_set_coalesce,
4141         .get_ringparam  = sky2_get_ringparam,
4142         .set_ringparam  = sky2_set_ringparam,
4143         .get_pauseparam = sky2_get_pauseparam,
4144         .set_pauseparam = sky2_set_pauseparam,
4145         .phys_id        = sky2_phys_id,
4146         .get_sset_count = sky2_get_sset_count,
4147         .get_ethtool_stats = sky2_get_ethtool_stats,
4148 };
4149
4150 #ifdef CONFIG_SKY2_DEBUG
4151
4152 static struct dentry *sky2_debug;
4153
4154
4155 /*
4156  * Read and parse the first part of Vital Product Data
4157  */
4158 #define VPD_SIZE        128
4159 #define VPD_MAGIC       0x82
4160
4161 static const struct vpd_tag {
4162         char tag[2];
4163         char *label;
4164 } vpd_tags[] = {
4165         { "PN", "Part Number" },
4166         { "EC", "Engineering Level" },
4167         { "MN", "Manufacturer" },
4168         { "SN", "Serial Number" },
4169         { "YA", "Asset Tag" },
4170         { "VL", "First Error Log Message" },
4171         { "VF", "Second Error Log Message" },
4172         { "VB", "Boot Agent ROM Configuration" },
4173         { "VE", "EFI UNDI Configuration" },
4174 };
4175
4176 static void sky2_show_vpd(struct seq_file *seq, struct sky2_hw *hw)
4177 {
4178         size_t vpd_size;
4179         loff_t offs;
4180         u8 len;
4181         unsigned char *buf;
4182         u16 reg2;
4183
4184         reg2 = sky2_pci_read16(hw, PCI_DEV_REG2);
4185         vpd_size = 1 << ( ((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
4186
4187         seq_printf(seq, "%s Product Data\n", pci_name(hw->pdev));
4188         buf = kmalloc(vpd_size, GFP_KERNEL);
4189         if (!buf) {
4190                 seq_puts(seq, "no memory!\n");
4191                 return;
4192         }
4193
4194         if (pci_read_vpd(hw->pdev, 0, vpd_size, buf) < 0) {
4195                 seq_puts(seq, "VPD read failed\n");
4196                 goto out;
4197         }
4198
4199         if (buf[0] != VPD_MAGIC) {
4200                 seq_printf(seq, "VPD tag mismatch: %#x\n", buf[0]);
4201                 goto out;
4202         }
4203         len = buf[1];
4204         if (len == 0 || len > vpd_size - 4) {
4205                 seq_printf(seq, "Invalid id length: %d\n", len);
4206                 goto out;
4207         }
4208
4209         seq_printf(seq, "%.*s\n", len, buf + 3);
4210         offs = len + 3;
4211
4212         while (offs < vpd_size - 4) {
4213                 int i;
4214
4215                 if (!memcmp("RW", buf + offs, 2))       /* end marker */
4216                         break;
4217                 len = buf[offs + 2];
4218                 if (offs + len + 3 >= vpd_size)
4219                         break;
4220
4221                 for (i = 0; i < ARRAY_SIZE(vpd_tags); i++) {
4222                         if (!memcmp(vpd_tags[i].tag, buf + offs, 2)) {
4223                                 seq_printf(seq, " %s: %.*s\n",
4224                                            vpd_tags[i].label, len, buf + offs + 3);
4225                                 break;
4226                         }
4227                 }
4228                 offs += len + 3;
4229         }
4230 out:
4231         kfree(buf);
4232 }
4233
4234 static int sky2_debug_show(struct seq_file *seq, void *v)
4235 {
4236         struct net_device *dev = seq->private;
4237         const struct sky2_port *sky2 = netdev_priv(dev);
4238         struct sky2_hw *hw = sky2->hw;
4239         unsigned port = sky2->port;
4240         unsigned idx, last;
4241         int sop;
4242
4243         sky2_show_vpd(seq, hw);
4244
4245         seq_printf(seq, "\nIRQ src=%x mask=%x control=%x\n",
4246                    sky2_read32(hw, B0_ISRC),
4247                    sky2_read32(hw, B0_IMSK),
4248                    sky2_read32(hw, B0_Y2_SP_ICR));
4249
4250         if (!netif_running(dev)) {
4251                 seq_printf(seq, "network not running\n");
4252                 return 0;
4253         }
4254
4255         napi_disable(&hw->napi);
4256         last = sky2_read16(hw, STAT_PUT_IDX);
4257
4258         if (hw->st_idx == last)
4259                 seq_puts(seq, "Status ring (empty)\n");
4260         else {
4261                 seq_puts(seq, "Status ring\n");
4262                 for (idx = hw->st_idx; idx != last && idx < STATUS_RING_SIZE;
4263                      idx = RING_NEXT(idx, STATUS_RING_SIZE)) {
4264                         const struct sky2_status_le *le = hw->st_le + idx;
4265                         seq_printf(seq, "[%d] %#x %d %#x\n",
4266                                    idx, le->opcode, le->length, le->status);
4267                 }
4268                 seq_puts(seq, "\n");
4269         }
4270
4271         seq_printf(seq, "Tx ring pending=%u...%u report=%d done=%d\n",
4272                    sky2->tx_cons, sky2->tx_prod,
4273                    sky2_read16(hw, port == 0 ? STAT_TXA1_RIDX : STAT_TXA2_RIDX),
4274                    sky2_read16(hw, Q_ADDR(txqaddr[port], Q_DONE)));
4275
4276         /* Dump contents of tx ring */
4277         sop = 1;
4278         for (idx = sky2->tx_next; idx != sky2->tx_prod && idx < sky2->tx_ring_size;
4279              idx = RING_NEXT(idx, sky2->tx_ring_size)) {
4280                 const struct sky2_tx_le *le = sky2->tx_le + idx;
4281                 u32 a = le32_to_cpu(le->addr);
4282
4283                 if (sop)
4284                         seq_printf(seq, "%u:", idx);
4285                 sop = 0;
4286
4287                 switch(le->opcode & ~HW_OWNER) {
4288                 case OP_ADDR64:
4289                         seq_printf(seq, " %#x:", a);
4290                         break;
4291                 case OP_LRGLEN:
4292                         seq_printf(seq, " mtu=%d", a);
4293                         break;
4294                 case OP_VLAN:
4295                         seq_printf(seq, " vlan=%d", be16_to_cpu(le->length));
4296                         break;
4297                 case OP_TCPLISW:
4298                         seq_printf(seq, " csum=%#x", a);
4299                         break;
4300                 case OP_LARGESEND:
4301                         seq_printf(seq, " tso=%#x(%d)", a, le16_to_cpu(le->length));
4302                         break;
4303                 case OP_PACKET:
4304                         seq_printf(seq, " %#x(%d)", a, le16_to_cpu(le->length));
4305                         break;
4306                 case OP_BUFFER:
4307                         seq_printf(seq, " frag=%#x(%d)", a, le16_to_cpu(le->length));
4308                         break;
4309                 default:
4310                         seq_printf(seq, " op=%#x,%#x(%d)", le->opcode,
4311                                    a, le16_to_cpu(le->length));
4312                 }
4313
4314                 if (le->ctrl & EOP) {
4315                         seq_putc(seq, '\n');
4316                         sop = 1;
4317                 }
4318         }
4319
4320         seq_printf(seq, "\nRx ring hw get=%d put=%d last=%d\n",
4321                    sky2_read16(hw, Y2_QADDR(rxqaddr[port], PREF_UNIT_GET_IDX)),
4322                    sky2_read16(hw, Y2_QADDR(rxqaddr[port], PREF_UNIT_PUT_IDX)),
4323                    sky2_read16(hw, Y2_QADDR(rxqaddr[port], PREF_UNIT_LAST_IDX)));
4324
4325         sky2_read32(hw, B0_Y2_SP_LISR);
4326         napi_enable(&hw->napi);
4327         return 0;
4328 }
4329
4330 static int sky2_debug_open(struct inode *inode, struct file *file)
4331 {
4332         return single_open(file, sky2_debug_show, inode->i_private);
4333 }
4334
4335 static const struct file_operations sky2_debug_fops = {
4336         .owner          = THIS_MODULE,
4337         .open           = sky2_debug_open,
4338         .read           = seq_read,
4339         .llseek         = seq_lseek,
4340         .release        = single_release,
4341 };
4342
4343 /*
4344  * Use network device events to create/remove/rename
4345  * debugfs file entries
4346  */
4347 static int sky2_device_event(struct notifier_block *unused,
4348                              unsigned long event, void *ptr)
4349 {
4350         struct net_device *dev = ptr;
4351         struct sky2_port *sky2 = netdev_priv(dev);
4352
4353         if (dev->netdev_ops->ndo_open != sky2_up || !sky2_debug)
4354                 return NOTIFY_DONE;
4355
4356         switch(event) {
4357         case NETDEV_CHANGENAME:
4358                 if (sky2->debugfs) {
4359                         sky2->debugfs = debugfs_rename(sky2_debug, sky2->debugfs,
4360                                                        sky2_debug, dev->name);
4361                 }
4362                 break;
4363
4364         case NETDEV_GOING_DOWN:
4365                 if (sky2->debugfs) {
4366                         netdev_printk(KERN_DEBUG, dev, "remove debugfs\n");
4367                         debugfs_remove(sky2->debugfs);
4368                         sky2->debugfs = NULL;
4369                 }
4370                 break;
4371
4372         case NETDEV_UP:
4373                 sky2->debugfs = debugfs_create_file(dev->name, S_IRUGO,
4374                                                     sky2_debug, dev,
4375                                                     &sky2_debug_fops);
4376                 if (IS_ERR(sky2->debugfs))
4377                         sky2->debugfs = NULL;
4378         }
4379
4380         return NOTIFY_DONE;
4381 }
4382
4383 static struct notifier_block sky2_notifier = {
4384         .notifier_call = sky2_device_event,
4385 };
4386
4387
4388 static __init void sky2_debug_init(void)
4389 {
4390         struct dentry *ent;
4391
4392         ent = debugfs_create_dir("sky2", NULL);
4393         if (!ent || IS_ERR(ent))
4394                 return;
4395
4396         sky2_debug = ent;
4397         register_netdevice_notifier(&sky2_notifier);
4398 }
4399
4400 static __exit void sky2_debug_cleanup(void)
4401 {
4402         if (sky2_debug) {
4403                 unregister_netdevice_notifier(&sky2_notifier);
4404                 debugfs_remove(sky2_debug);
4405                 sky2_debug = NULL;
4406         }
4407 }
4408
4409 #else
4410 #define sky2_debug_init()
4411 #define sky2_debug_cleanup()
4412 #endif
4413
4414 /* Two copies of network device operations to handle special case of
4415    not allowing netpoll on second port */
4416 static const struct net_device_ops sky2_netdev_ops[2] = {
4417   {
4418         .ndo_open               = sky2_up,
4419         .ndo_stop               = sky2_down,
4420         .ndo_start_xmit         = sky2_xmit_frame,
4421         .ndo_do_ioctl           = sky2_ioctl,
4422         .ndo_validate_addr      = eth_validate_addr,
4423         .ndo_set_mac_address    = sky2_set_mac_address,
4424         .ndo_set_multicast_list = sky2_set_multicast,
4425         .ndo_change_mtu         = sky2_change_mtu,
4426         .ndo_tx_timeout         = sky2_tx_timeout,
4427 #ifdef SKY2_VLAN_TAG_USED
4428         .ndo_vlan_rx_register   = sky2_vlan_rx_register,
4429 #endif
4430 #ifdef CONFIG_NET_POLL_CONTROLLER
4431         .ndo_poll_controller    = sky2_netpoll,
4432 #endif
4433   },
4434   {
4435         .ndo_open               = sky2_up,
4436         .ndo_stop               = sky2_down,
4437         .ndo_start_xmit         = sky2_xmit_frame,
4438         .ndo_do_ioctl           = sky2_ioctl,
4439         .ndo_validate_addr      = eth_validate_addr,
4440         .ndo_set_mac_address    = sky2_set_mac_address,
4441         .ndo_set_multicast_list = sky2_set_multicast,
4442         .ndo_change_mtu         = sky2_change_mtu,
4443         .ndo_tx_timeout         = sky2_tx_timeout,
4444 #ifdef SKY2_VLAN_TAG_USED
4445         .ndo_vlan_rx_register   = sky2_vlan_rx_register,
4446 #endif
4447   },
4448 };
4449
4450 /* Initialize network device */
4451 static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw,
4452                                                      unsigned port,
4453                                                      int highmem, int wol)
4454 {
4455         struct sky2_port *sky2;
4456         struct net_device *dev = alloc_etherdev(sizeof(*sky2));
4457
4458         if (!dev) {
4459                 dev_err(&hw->pdev->dev, "etherdev alloc failed\n");
4460                 return NULL;
4461         }
4462
4463         SET_NETDEV_DEV(dev, &hw->pdev->dev);
4464         dev->irq = hw->pdev->irq;
4465         SET_ETHTOOL_OPS(dev, &sky2_ethtool_ops);
4466         dev->watchdog_timeo = TX_WATCHDOG;
4467         dev->netdev_ops = &sky2_netdev_ops[port];
4468
4469         sky2 = netdev_priv(dev);
4470         sky2->netdev = dev;
4471         sky2->hw = hw;
4472         sky2->msg_enable = netif_msg_init(debug, default_msg);
4473
4474         /* Auto speed and flow control */
4475         sky2->flags = SKY2_FLAG_AUTO_SPEED | SKY2_FLAG_AUTO_PAUSE;
4476         if (hw->chip_id != CHIP_ID_YUKON_XL)
4477                 sky2->flags |= SKY2_FLAG_RX_CHECKSUM;
4478
4479         sky2->flow_mode = FC_BOTH;
4480
4481         sky2->duplex = -1;
4482         sky2->speed = -1;
4483         sky2->advertising = sky2_supported_modes(hw);
4484         sky2->wol = wol;
4485
4486         spin_lock_init(&sky2->phy_lock);
4487
4488         sky2->tx_pending = TX_DEF_PENDING;
4489         sky2->tx_ring_size = roundup_pow_of_two(TX_DEF_PENDING+1);
4490         sky2->rx_pending = RX_DEF_PENDING;
4491
4492         hw->dev[port] = dev;
4493
4494         sky2->port = port;
4495
4496         dev->features |= NETIF_F_TSO | NETIF_F_IP_CSUM | NETIF_F_SG;
4497         if (highmem)
4498                 dev->features |= NETIF_F_HIGHDMA;
4499
4500 #ifdef SKY2_VLAN_TAG_USED
4501         /* The workaround for FE+ status conflicts with VLAN tag detection. */
4502         if (!(sky2->hw->chip_id == CHIP_ID_YUKON_FE_P &&
4503               sky2->hw->chip_rev == CHIP_REV_YU_FE2_A0)) {
4504                 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
4505         }
4506 #endif
4507
4508         /* read the mac address */
4509         memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port * 8, ETH_ALEN);
4510         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
4511
4512         return dev;
4513 }
4514
4515 static void __devinit sky2_show_addr(struct net_device *dev)
4516 {
4517         const struct sky2_port *sky2 = netdev_priv(dev);
4518
4519         netif_info(sky2, probe, dev, "addr %pM\n", dev->dev_addr);
4520 }
4521
4522 /* Handle software interrupt used during MSI test */
4523 static irqreturn_t __devinit sky2_test_intr(int irq, void *dev_id)
4524 {
4525         struct sky2_hw *hw = dev_id;
4526         u32 status = sky2_read32(hw, B0_Y2_SP_ISRC2);
4527
4528         if (status == 0)
4529                 return IRQ_NONE;
4530
4531         if (status & Y2_IS_IRQ_SW) {
4532                 hw->flags |= SKY2_HW_USE_MSI;
4533                 wake_up(&hw->msi_wait);
4534                 sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
4535         }
4536         sky2_write32(hw, B0_Y2_SP_ICR, 2);
4537
4538         return IRQ_HANDLED;
4539 }
4540
4541 /* Test interrupt path by forcing a a software IRQ */
4542 static int __devinit sky2_test_msi(struct sky2_hw *hw)
4543 {
4544         struct pci_dev *pdev = hw->pdev;
4545         int err;
4546
4547         init_waitqueue_head (&hw->msi_wait);
4548
4549         sky2_write32(hw, B0_IMSK, Y2_IS_IRQ_SW);
4550
4551         err = request_irq(pdev->irq, sky2_test_intr, 0, DRV_NAME, hw);
4552         if (err) {
4553                 dev_err(&pdev->dev, "cannot assign irq %d\n", pdev->irq);
4554                 return err;
4555         }
4556
4557         sky2_write8(hw, B0_CTST, CS_ST_SW_IRQ);
4558         sky2_read8(hw, B0_CTST);
4559
4560         wait_event_timeout(hw->msi_wait, (hw->flags & SKY2_HW_USE_MSI), HZ/10);
4561
4562         if (!(hw->flags & SKY2_HW_USE_MSI)) {
4563                 /* MSI test failed, go back to INTx mode */
4564                 dev_info(&pdev->dev, "No interrupt generated using MSI, "
4565                          "switching to INTx mode.\n");
4566
4567                 err = -EOPNOTSUPP;
4568                 sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
4569         }
4570
4571         sky2_write32(hw, B0_IMSK, 0);
4572         sky2_read32(hw, B0_IMSK);
4573
4574         free_irq(pdev->irq, hw);
4575
4576         return err;
4577 }
4578
4579 /* This driver supports yukon2 chipset only */
4580 static const char *sky2_name(u8 chipid, char *buf, int sz)
4581 {
4582         const char *name[] = {
4583                 "XL",           /* 0xb3 */
4584                 "EC Ultra",     /* 0xb4 */
4585                 "Extreme",      /* 0xb5 */
4586                 "EC",           /* 0xb6 */
4587                 "FE",           /* 0xb7 */
4588                 "FE+",          /* 0xb8 */
4589                 "Supreme",      /* 0xb9 */
4590                 "UL 2",         /* 0xba */
4591                 "Unknown",      /* 0xbb */
4592                 "Optima",       /* 0xbc */
4593         };
4594
4595         if (chipid >= CHIP_ID_YUKON_XL && chipid <= CHIP_ID_YUKON_OPT)
4596                 strncpy(buf, name[chipid - CHIP_ID_YUKON_XL], sz);
4597         else
4598                 snprintf(buf, sz, "(chip %#x)", chipid);
4599         return buf;
4600 }
4601
4602 static int __devinit sky2_probe(struct pci_dev *pdev,
4603                                 const struct pci_device_id *ent)
4604 {
4605         struct net_device *dev;
4606         struct sky2_hw *hw;
4607         int err, using_dac = 0, wol_default;
4608         u32 reg;
4609         char buf1[16];
4610
4611         err = pci_enable_device(pdev);
4612         if (err) {
4613                 dev_err(&pdev->dev, "cannot enable PCI device\n");
4614                 goto err_out;
4615         }
4616
4617         /* Get configuration information
4618          * Note: only regular PCI config access once to test for HW issues
4619          *       other PCI access through shared memory for speed and to
4620          *       avoid MMCONFIG problems.
4621          */
4622         err = pci_read_config_dword(pdev, PCI_DEV_REG2, &reg);
4623         if (err) {
4624                 dev_err(&pdev->dev, "PCI read config failed\n");
4625                 goto err_out;
4626         }
4627
4628         if (~reg == 0) {
4629                 dev_err(&pdev->dev, "PCI configuration read error\n");
4630                 goto err_out;
4631         }
4632
4633         err = pci_request_regions(pdev, DRV_NAME);
4634         if (err) {
4635                 dev_err(&pdev->dev, "cannot obtain PCI resources\n");
4636                 goto err_out_disable;
4637         }
4638
4639         pci_set_master(pdev);
4640
4641         if (sizeof(dma_addr_t) > sizeof(u32) &&
4642             !(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))) {
4643                 using_dac = 1;
4644                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
4645                 if (err < 0) {
4646                         dev_err(&pdev->dev, "unable to obtain 64 bit DMA "
4647                                 "for consistent allocations\n");
4648                         goto err_out_free_regions;
4649                 }
4650         } else {
4651                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
4652                 if (err) {
4653                         dev_err(&pdev->dev, "no usable DMA configuration\n");
4654                         goto err_out_free_regions;
4655                 }
4656         }
4657
4658
4659 #ifdef __BIG_ENDIAN
4660         /* The sk98lin vendor driver uses hardware byte swapping but
4661          * this driver uses software swapping.
4662          */
4663         reg &= ~PCI_REV_DESC;
4664         err = pci_write_config_dword(pdev,PCI_DEV_REG2, reg);
4665         if (err) {
4666                 dev_err(&pdev->dev, "PCI write config failed\n");
4667                 goto err_out_free_regions;
4668         }
4669 #endif
4670
4671         wol_default = device_may_wakeup(&pdev->dev) ? WAKE_MAGIC : 0;
4672
4673         err = -ENOMEM;
4674
4675         hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:")
4676                      + strlen(pci_name(pdev)) + 1, GFP_KERNEL);
4677         if (!hw) {
4678                 dev_err(&pdev->dev, "cannot allocate hardware struct\n");
4679                 goto err_out_free_regions;
4680         }
4681
4682         hw->pdev = pdev;
4683         sprintf(hw->irq_name, DRV_NAME "@pci:%s", pci_name(pdev));
4684
4685         hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000);
4686         if (!hw->regs) {
4687                 dev_err(&pdev->dev, "cannot map device registers\n");
4688                 goto err_out_free_hw;
4689         }
4690
4691         /* ring for status responses */
4692         hw->st_le = pci_alloc_consistent(pdev, STATUS_LE_BYTES, &hw->st_dma);
4693         if (!hw->st_le)
4694                 goto err_out_iounmap;
4695
4696         err = sky2_init(hw);
4697         if (err)
4698                 goto err_out_iounmap;
4699
4700         dev_info(&pdev->dev, "Yukon-2 %s chip revision %d\n",
4701                  sky2_name(hw->chip_id, buf1, sizeof(buf1)), hw->chip_rev);
4702
4703         sky2_reset(hw);
4704
4705         dev = sky2_init_netdev(hw, 0, using_dac, wol_default);
4706         if (!dev) {
4707                 err = -ENOMEM;
4708                 goto err_out_free_pci;
4709         }
4710
4711         if (!disable_msi && pci_enable_msi(pdev) == 0) {
4712                 err = sky2_test_msi(hw);
4713                 if (err == -EOPNOTSUPP)
4714                         pci_disable_msi(pdev);
4715                 else if (err)
4716                         goto err_out_free_netdev;
4717         }
4718
4719         err = register_netdev(dev);
4720         if (err) {
4721                 dev_err(&pdev->dev, "cannot register net device\n");
4722                 goto err_out_free_netdev;
4723         }
4724
4725         netif_carrier_off(dev);
4726
4727         netif_napi_add(dev, &hw->napi, sky2_poll, NAPI_WEIGHT);
4728
4729         err = request_irq(pdev->irq, sky2_intr,
4730                           (hw->flags & SKY2_HW_USE_MSI) ? 0 : IRQF_SHARED,
4731                           hw->irq_name, hw);
4732         if (err) {
4733                 dev_err(&pdev->dev, "cannot assign irq %d\n", pdev->irq);
4734                 goto err_out_unregister;
4735         }
4736         sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
4737         napi_enable(&hw->napi);
4738
4739         sky2_show_addr(dev);
4740
4741         if (hw->ports > 1) {
4742                 struct net_device *dev1;
4743
4744                 err = -ENOMEM;
4745                 dev1 = sky2_init_netdev(hw, 1, using_dac, wol_default);
4746                 if (dev1 && (err = register_netdev(dev1)) == 0)
4747                         sky2_show_addr(dev1);
4748                 else {
4749                         dev_warn(&pdev->dev,
4750                                  "register of second port failed (%d)\n", err);
4751                         hw->dev[1] = NULL;
4752                         hw->ports = 1;
4753                         if (dev1)
4754                                 free_netdev(dev1);
4755                 }
4756         }
4757
4758         setup_timer(&hw->watchdog_timer, sky2_watchdog, (unsigned long) hw);
4759         INIT_WORK(&hw->restart_work, sky2_restart);
4760
4761         pci_set_drvdata(pdev, hw);
4762         pdev->d3_delay = 150;
4763
4764         return 0;
4765
4766 err_out_unregister:
4767         if (hw->flags & SKY2_HW_USE_MSI)
4768                 pci_disable_msi(pdev);
4769         unregister_netdev(dev);
4770 err_out_free_netdev:
4771         free_netdev(dev);
4772 err_out_free_pci:
4773         sky2_write8(hw, B0_CTST, CS_RST_SET);
4774         pci_free_consistent(pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma);
4775 err_out_iounmap:
4776         iounmap(hw->regs);
4777 err_out_free_hw:
4778         kfree(hw);
4779 err_out_free_regions:
4780         pci_release_regions(pdev);
4781 err_out_disable:
4782         pci_disable_device(pdev);
4783 err_out:
4784         pci_set_drvdata(pdev, NULL);
4785         return err;
4786 }
4787
4788 static void __devexit sky2_remove(struct pci_dev *pdev)
4789 {
4790         struct sky2_hw *hw = pci_get_drvdata(pdev);
4791         int i;
4792
4793         if (!hw)
4794                 return;
4795
4796         del_timer_sync(&hw->watchdog_timer);
4797         cancel_work_sync(&hw->restart_work);
4798
4799         for (i = hw->ports-1; i >= 0; --i)
4800                 unregister_netdev(hw->dev[i]);
4801
4802         sky2_write32(hw, B0_IMSK, 0);
4803
4804         sky2_power_aux(hw);
4805
4806         sky2_write8(hw, B0_CTST, CS_RST_SET);
4807         sky2_read8(hw, B0_CTST);
4808
4809         free_irq(pdev->irq, hw);
4810         if (hw->flags & SKY2_HW_USE_MSI)
4811                 pci_disable_msi(pdev);
4812         pci_free_consistent(pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma);
4813         pci_release_regions(pdev);
4814         pci_disable_device(pdev);
4815
4816         for (i = hw->ports-1; i >= 0; --i)
4817                 free_netdev(hw->dev[i]);
4818
4819         iounmap(hw->regs);
4820         kfree(hw);
4821
4822         pci_set_drvdata(pdev, NULL);
4823 }
4824
4825 static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
4826 {
4827         struct sky2_hw *hw = pci_get_drvdata(pdev);
4828         int i, wol = 0;
4829
4830         if (!hw)
4831                 return 0;
4832
4833         del_timer_sync(&hw->watchdog_timer);
4834         cancel_work_sync(&hw->restart_work);
4835
4836         rtnl_lock();
4837         for (i = 0; i < hw->ports; i++) {
4838                 struct net_device *dev = hw->dev[i];
4839                 struct sky2_port *sky2 = netdev_priv(dev);
4840
4841                 sky2_detach(dev);
4842
4843                 if (sky2->wol)
4844                         sky2_wol_init(sky2);
4845
4846                 wol |= sky2->wol;
4847         }
4848
4849         device_set_wakeup_enable(&pdev->dev, wol != 0);
4850
4851         sky2_write32(hw, B0_IMSK, 0);
4852         napi_disable(&hw->napi);
4853         sky2_power_aux(hw);
4854         rtnl_unlock();
4855
4856         pci_save_state(pdev);
4857         pci_enable_wake(pdev, pci_choose_state(pdev, state), wol);
4858         pci_set_power_state(pdev, pci_choose_state(pdev, state));
4859
4860         return 0;
4861 }
4862
4863 #ifdef CONFIG_PM
4864 static int sky2_resume(struct pci_dev *pdev)
4865 {
4866         struct sky2_hw *hw = pci_get_drvdata(pdev);
4867         int i, err;
4868
4869         if (!hw)
4870                 return 0;
4871
4872         rtnl_lock();
4873         err = pci_set_power_state(pdev, PCI_D0);
4874         if (err)
4875                 goto out;
4876
4877         err = pci_restore_state(pdev);
4878         if (err)
4879                 goto out;
4880
4881         pci_enable_wake(pdev, PCI_D0, 0);
4882
4883         /* Re-enable all clocks */
4884         err = pci_write_config_dword(pdev, PCI_DEV_REG3, 0);
4885         if (err) {
4886                 dev_err(&pdev->dev, "PCI write config failed\n");
4887                 goto out;
4888         }
4889
4890         sky2_reset(hw);
4891         sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
4892         napi_enable(&hw->napi);
4893
4894         for (i = 0; i < hw->ports; i++) {
4895                 err = sky2_reattach(hw->dev[i]);
4896                 if (err)
4897                         goto out;
4898         }
4899         rtnl_unlock();
4900
4901         return 0;
4902 out:
4903         rtnl_unlock();
4904
4905         dev_err(&pdev->dev, "resume failed (%d)\n", err);
4906         pci_disable_device(pdev);
4907         return err;
4908 }
4909 #endif
4910
4911 static void sky2_shutdown(struct pci_dev *pdev)
4912 {
4913         sky2_suspend(pdev, PMSG_SUSPEND);
4914 }
4915
4916 static struct pci_driver sky2_driver = {
4917         .name = DRV_NAME,
4918         .id_table = sky2_id_table,
4919         .probe = sky2_probe,
4920         .remove = __devexit_p(sky2_remove),
4921 #ifdef CONFIG_PM
4922         .suspend = sky2_suspend,
4923         .resume = sky2_resume,
4924 #endif
4925         .shutdown = sky2_shutdown,
4926 };
4927
4928 static int __init sky2_init_module(void)
4929 {
4930         pr_info("driver version " DRV_VERSION "\n");
4931
4932         sky2_debug_init();
4933         return pci_register_driver(&sky2_driver);
4934 }
4935
4936 static void __exit sky2_cleanup_module(void)
4937 {
4938         pci_unregister_driver(&sky2_driver);
4939         sky2_debug_cleanup();
4940 }
4941
4942 module_init(sky2_init_module);
4943 module_exit(sky2_cleanup_module);
4944
4945 MODULE_DESCRIPTION("Marvell Yukon 2 Gigabit Ethernet driver");
4946 MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
4947 MODULE_LICENSE("GPL");
4948 MODULE_VERSION(DRV_VERSION);