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