qemu/roms/ipxe/src/drivers/net/sky2.c

   1 /*
   2  * iPXE driver for Marvell Yukon 2 chipset. Derived from Linux sky2 driver
   3  * (v1.22), which was based on earlier sk98lin and skge drivers.
   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  * Modified for iPXE, April 2009 by Joshua Oreman
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  25  * 02110-1301, USA.
  26  */
  27
  28 FILE_LICENCE ( GPL2_ONLY );
  29
  30 #include <stdint.h>
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <unistd.h>
  34 #include <ipxe/ethernet.h>
  35 #include <ipxe/if_ether.h>
  36 #include <ipxe/iobuf.h>
  37 #include <ipxe/malloc.h>
  38 #include <ipxe/pci.h>
  39 #include <byteswap.h>
  40 #include <mii.h>
  41
  42 #include "sky2.h"
  43
  44 #define DRV_NAME                "sky2"
  45 #define DRV_VERSION             "1.22"
  46 #define PFX                     DRV_NAME " "
  47
  48 /*
  49  * The Yukon II chipset takes 64 bit command blocks (called list elements)
  50  * that are organized into three (receive, transmit, status) different rings
  51  * similar to Tigon3.
  52  *
  53  * Each ring start must be aligned to a 4k boundary. You will get mysterious
  54  * "invalid LE" errors if they're not.
  55  *
  56  * The card silently forces each ring size to be at least 128. If you
  57  * act as though one of them is smaller (by setting the below
  58  * #defines) you'll get bad bugs.
  59  */
  60
  61 #define RX_LE_SIZE              128
  62 #define RX_LE_BYTES             (RX_LE_SIZE*sizeof(struct sky2_rx_le))
  63 #define RX_RING_ALIGN           4096
  64 #define RX_PENDING              (RX_LE_SIZE/6 - 2)
  65
  66 #define TX_RING_SIZE            128
  67 #define TX_PENDING              (TX_RING_SIZE - 1)
  68 #define TX_RING_ALIGN           4096
  69 #define MAX_SKB_TX_LE           4
  70
  71 #define STATUS_RING_SIZE        512     /* 2 ports * (TX + RX) */
  72 #define STATUS_LE_BYTES         (STATUS_RING_SIZE*sizeof(struct sky2_status_le))
  73 #define STATUS_RING_ALIGN       4096
  74 #define PHY_RETRIES             1000
  75
  76 #define SKY2_EEPROM_MAGIC       0x9955aabb
  77
  78
  79 #define RING_NEXT(x,s)  (((x)+1) & ((s)-1))
  80
  81 static struct pci_device_id sky2_id_table[] = {
  82         PCI_ROM(0x1148, 0x9000, "sk9sxx", "Syskonnect SK-9Sxx", 0),
  83         PCI_ROM(0x1148, 0x9e00, "sk9exx", "Syskonnect SK-9Exx", 0),
  84         PCI_ROM(0x1186, 0x4b00, "dge560t", "D-Link DGE-560T", 0),
  85         PCI_ROM(0x1186, 0x4001, "dge550sx", "D-Link DGE-550SX", 0),
  86         PCI_ROM(0x1186, 0x4b02, "dge560sx", "D-Link DGE-560SX", 0),
  87         PCI_ROM(0x1186, 0x4b03, "dge550t", "D-Link DGE-550T", 0),
  88         PCI_ROM(0x11ab, 0x4340, "m88e8021", "Marvell 88E8021", 0),
  89         PCI_ROM(0x11ab, 0x4341, "m88e8022", "Marvell 88E8022", 0),
  90         PCI_ROM(0x11ab, 0x4342, "m88e8061", "Marvell 88E8061", 0),
  91         PCI_ROM(0x11ab, 0x4343, "m88e8062", "Marvell 88E8062", 0),
  92         PCI_ROM(0x11ab, 0x4344, "m88e8021b", "Marvell 88E8021", 0),
  93         PCI_ROM(0x11ab, 0x4345, "m88e8022b", "Marvell 88E8022", 0),
  94         PCI_ROM(0x11ab, 0x4346, "m88e8061b", "Marvell 88E8061", 0),
  95         PCI_ROM(0x11ab, 0x4347, "m88e8062b", "Marvell 88E8062", 0),
  96         PCI_ROM(0x11ab, 0x4350, "m88e8035", "Marvell 88E8035", 0),
  97         PCI_ROM(0x11ab, 0x4351, "m88e8036", "Marvell 88E8036", 0),
  98         PCI_ROM(0x11ab, 0x4352, "m88e8038", "Marvell 88E8038", 0),
  99         PCI_ROM(0x11ab, 0x4353, "m88e8039", "Marvell 88E8039", 0),
 100         PCI_ROM(0x11ab, 0x4354, "m88e8040", "Marvell 88E8040", 0),
 101         PCI_ROM(0x11ab, 0x4355, "m88e8040t", "Marvell 88E8040T", 0),
 102         PCI_ROM(0x11ab, 0x4356, "m88ec033", "Marvel 88EC033", 0),
 103         PCI_ROM(0x11ab, 0x4357, "m88e8042", "Marvell 88E8042", 0),
 104         PCI_ROM(0x11ab, 0x435a, "m88e8048", "Marvell 88E8048", 0),
 105         PCI_ROM(0x11ab, 0x4360, "m88e8052", "Marvell 88E8052", 0),
 106         PCI_ROM(0x11ab, 0x4361, "m88e8050", "Marvell 88E8050", 0),
 107         PCI_ROM(0x11ab, 0x4362, "m88e8053", "Marvell 88E8053", 0),
 108         PCI_ROM(0x11ab, 0x4363, "m88e8055", "Marvell 88E8055", 0),
 109         PCI_ROM(0x11ab, 0x4364, "m88e8056", "Marvell 88E8056", 0),
 110         PCI_ROM(0x11ab, 0x4365, "m88e8070", "Marvell 88E8070", 0),
 111         PCI_ROM(0x11ab, 0x4366, "m88ec036", "Marvell 88EC036", 0),
 112         PCI_ROM(0x11ab, 0x4367, "m88ec032", "Marvell 88EC032", 0),
 113         PCI_ROM(0x11ab, 0x4368, "m88ec034", "Marvell 88EC034", 0),
 114         PCI_ROM(0x11ab, 0x4369, "m88ec042", "Marvell 88EC042", 0),
 115         PCI_ROM(0x11ab, 0x436a, "m88e8058", "Marvell 88E8058", 0),
 116         PCI_ROM(0x11ab, 0x436b, "m88e8071", "Marvell 88E8071", 0),
 117         PCI_ROM(0x11ab, 0x436c, "m88e8072", "Marvell 88E8072", 0),
 118         PCI_ROM(0x11ab, 0x436d, "m88e8055b", "Marvell 88E8055", 0),
 119         PCI_ROM(0x11ab, 0x4370, "m88e8075", "Marvell 88E8075", 0),
 120         PCI_ROM(0x11ab, 0x4380, "m88e8057", "Marvell 88E8057", 0)
 121 };
 122
 123 /* Avoid conditionals by using array */
 124 static const unsigned txqaddr[] = { Q_XA1, Q_XA2 };
 125 static const unsigned rxqaddr[] = { Q_R1, Q_R2 };
 126 static const u32 portirq_msk[] = { Y2_IS_PORT_1, Y2_IS_PORT_2 };
 127
 128 static void sky2_set_multicast(struct net_device *dev);
 129
 130 /* Access to PHY via serial interconnect */
 131 static int gm_phy_write(struct sky2_hw *hw, unsigned port, u16 reg, u16 val)
 132 {
 133         int i;
 134
 135         gma_write16(hw, port, GM_SMI_DATA, val);
 136         gma_write16(hw, port, GM_SMI_CTRL,
 137                     GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) | GM_SMI_CT_REG_AD(reg));
 138
 139         for (i = 0; i < PHY_RETRIES; i++) {
 140                 u16 ctrl = gma_read16(hw, port, GM_SMI_CTRL);
 141                 if (ctrl == 0xffff)
 142                         goto io_error;
 143
 144                 if (!(ctrl & GM_SMI_CT_BUSY))
 145                         return 0;
 146
 147                 udelay(10);
 148         }
 149
 150         DBG(PFX "%s: phy write timeout\n", hw->dev[port]->name);
 151         return -ETIMEDOUT;
 152
 153 io_error:
 154         DBG(PFX "%s: phy I/O error\n", hw->dev[port]->name);
 155         return -EIO;
 156 }
 157
 158 static int __gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg, u16 *val)
 159 {
 160         int i;
 161
 162         gma_write16(hw, port, GM_SMI_CTRL, GM_SMI_CT_PHY_AD(PHY_ADDR_MARV)
 163                     | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD);
 164
 165         for (i = 0; i < PHY_RETRIES; i++) {
 166                 u16 ctrl = gma_read16(hw, port, GM_SMI_CTRL);
 167                 if (ctrl == 0xffff)
 168                         goto io_error;
 169
 170                 if (ctrl & GM_SMI_CT_RD_VAL) {
 171                         *val = gma_read16(hw, port, GM_SMI_DATA);
 172                         return 0;
 173                 }
 174
 175                 udelay(10);
 176         }
 177
 178         DBG(PFX "%s: phy read timeout\n", hw->dev[port]->name);
 179         return -ETIMEDOUT;
 180 io_error:
 181         DBG(PFX "%s: phy I/O error\n", hw->dev[port]->name);
 182         return -EIO;
 183 }
 184
 185 static inline u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg)
 186 {
 187         u16 v = 0;
 188         __gm_phy_read(hw, port, reg, &v);
 189         return v;
 190 }
 191
 192
 193 static void sky2_power_on(struct sky2_hw *hw)
 194 {
 195         /* switch power to VCC (WA for VAUX problem) */
 196         sky2_write8(hw, B0_POWER_CTRL,
 197                     PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON);
 198
 199         /* disable Core Clock Division, */
 200         sky2_write32(hw, B2_Y2_CLK_CTRL, Y2_CLK_DIV_DIS);
 201
 202         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
 203                 /* enable bits are inverted */
 204                 sky2_write8(hw, B2_Y2_CLK_GATE,
 205                             Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
 206                             Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
 207                             Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS);
 208         else
 209                 sky2_write8(hw, B2_Y2_CLK_GATE, 0);
 210
 211         if (hw->flags & SKY2_HW_ADV_POWER_CTL) {
 212                 u32 reg;
 213
 214                 sky2_pci_write32(hw, PCI_DEV_REG3, 0);
 215
 216                 reg = sky2_pci_read32(hw, PCI_DEV_REG4);
 217                 /* set all bits to 0 except bits 15..12 and 8 */
 218                 reg &= P_ASPM_CONTROL_MSK;
 219                 sky2_pci_write32(hw, PCI_DEV_REG4, reg);
 220
 221                 reg = sky2_pci_read32(hw, PCI_DEV_REG5);
 222                 /* set all bits to 0 except bits 28 & 27 */
 223                 reg &= P_CTL_TIM_VMAIN_AV_MSK;
 224                 sky2_pci_write32(hw, PCI_DEV_REG5, reg);
 225
 226                 sky2_pci_write32(hw, PCI_CFG_REG_1, 0);
 227
 228                 /* Enable workaround for dev 4.107 on Yukon-Ultra & Extreme */
 229                 reg = sky2_read32(hw, B2_GP_IO);
 230                 reg |= GLB_GPIO_STAT_RACE_DIS;
 231                 sky2_write32(hw, B2_GP_IO, reg);
 232
 233                 sky2_read32(hw, B2_GP_IO);
 234         }
 235 }
 236
 237 static void sky2_power_aux(struct sky2_hw *hw)
 238 {
 239         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
 240                 sky2_write8(hw, B2_Y2_CLK_GATE, 0);
 241         else
 242                 /* enable bits are inverted */
 243                 sky2_write8(hw, B2_Y2_CLK_GATE,
 244                             Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
 245                             Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
 246                             Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS);
 247
 248         /* switch power to VAUX */
 249         if (sky2_read16(hw, B0_CTST) & Y2_VAUX_AVAIL)
 250                 sky2_write8(hw, B0_POWER_CTRL,
 251                             (PC_VAUX_ENA | PC_VCC_ENA |
 252                              PC_VAUX_ON | PC_VCC_OFF));
 253 }
 254
 255 static void sky2_gmac_reset(struct sky2_hw *hw, unsigned port)
 256 {
 257         u16 reg;
 258
 259         /* disable all GMAC IRQ's */
 260         sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0);
 261
 262         gma_write16(hw, port, GM_MC_ADDR_H1, 0);        /* clear MC hash */
 263         gma_write16(hw, port, GM_MC_ADDR_H2, 0);
 264         gma_write16(hw, port, GM_MC_ADDR_H3, 0);
 265         gma_write16(hw, port, GM_MC_ADDR_H4, 0);
 266
 267         reg = gma_read16(hw, port, GM_RX_CTRL);
 268         reg |= GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA;
 269         gma_write16(hw, port, GM_RX_CTRL, reg);
 270 }
 271
 272 /* flow control to advertise bits */
 273 static const u16 copper_fc_adv[] = {
 274         [FC_NONE]       = 0,
 275         [FC_TX]         = PHY_M_AN_ASP,
 276         [FC_RX]         = PHY_M_AN_PC,
 277         [FC_BOTH]       = PHY_M_AN_PC | PHY_M_AN_ASP,
 278 };
 279
 280 /* flow control to advertise bits when using 1000BaseX */
 281 static const u16 fiber_fc_adv[] = {
 282         [FC_NONE] = PHY_M_P_NO_PAUSE_X,
 283         [FC_TX]   = PHY_M_P_ASYM_MD_X,
 284         [FC_RX]   = PHY_M_P_SYM_MD_X,
 285         [FC_BOTH] = PHY_M_P_BOTH_MD_X,
 286 };
 287
 288 /* flow control to GMA disable bits */
 289 static const u16 gm_fc_disable[] = {
 290         [FC_NONE] = GM_GPCR_FC_RX_DIS | GM_GPCR_FC_TX_DIS,
 291         [FC_TX]   = GM_GPCR_FC_RX_DIS,
 292         [FC_RX]   = GM_GPCR_FC_TX_DIS,
 293         [FC_BOTH] = 0,
 294 };
 295
 296
 297 static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
 298 {
 299         struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
 300         u16 ctrl, ct1000, adv, pg, ledctrl, ledover, reg;
 301
 302         if (sky2->autoneg == AUTONEG_ENABLE &&
 303             !(hw->flags & SKY2_HW_NEWER_PHY)) {
 304                 u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL);
 305
 306                 ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK |
 307                            PHY_M_EC_MAC_S_MSK);
 308                 ectrl |= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ);
 309
 310                 /* on PHY 88E1040 Rev.D0 (and newer) downshift control changed */
 311                 if (hw->chip_id == CHIP_ID_YUKON_EC)
 312                         /* set downshift counter to 3x and enable downshift */
 313                         ectrl |= PHY_M_EC_DSC_2(2) | PHY_M_EC_DOWN_S_ENA;
 314                 else
 315                         /* set master & slave downshift counter to 1x */
 316                         ectrl |= PHY_M_EC_M_DSC(0) | PHY_M_EC_S_DSC(1);
 317
 318                 gm_phy_write(hw, port, PHY_MARV_EXT_CTRL, ectrl);
 319         }
 320
 321         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 322         if (sky2_is_copper(hw)) {
 323                 if (!(hw->flags & SKY2_HW_GIGABIT)) {
 324                         /* enable automatic crossover */
 325                         ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO) >> 1;
 326
 327                         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
 328                             hw->chip_rev == CHIP_REV_YU_FE2_A0) {
 329                                 u16 spec;
 330
 331                                 /* Enable Class A driver for FE+ A0 */
 332                                 spec = gm_phy_read(hw, port, PHY_MARV_FE_SPEC_2);
 333                                 spec |= PHY_M_FESC_SEL_CL_A;
 334                                 gm_phy_write(hw, port, PHY_MARV_FE_SPEC_2, spec);
 335                         }
 336                 } else {
 337                         /* disable energy detect */
 338                         ctrl &= ~PHY_M_PC_EN_DET_MSK;
 339
 340                         /* enable automatic crossover */
 341                         ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO);
 342
 343                         /* downshift on PHY 88E1112 and 88E1149 is changed */
 344                         if (sky2->autoneg == AUTONEG_ENABLE
 345                             && (hw->flags & SKY2_HW_NEWER_PHY)) {
 346                                 /* set downshift counter to 3x and enable downshift */
 347                                 ctrl &= ~PHY_M_PC_DSC_MSK;
 348                                 ctrl |= PHY_M_PC_DSC(2) | PHY_M_PC_DOWN_S_ENA;
 349                         }
 350                 }
 351         } else {
 352                 /* workaround for deviation #4.88 (CRC errors) */
 353                 /* disable Automatic Crossover */
 354
 355                 ctrl &= ~PHY_M_PC_MDIX_MSK;
 356         }
 357
 358         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 359
 360         /* special setup for PHY 88E1112 Fiber */
 361         if (hw->chip_id == CHIP_ID_YUKON_XL && (hw->flags & SKY2_HW_FIBRE_PHY)) {
 362                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
 363
 364                 /* Fiber: select 1000BASE-X only mode MAC Specific Ctrl Reg. */
 365                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
 366                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 367                 ctrl &= ~PHY_M_MAC_MD_MSK;
 368                 ctrl |= PHY_M_MAC_MODE_SEL(PHY_M_MAC_MD_1000BX);
 369                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 370
 371                 if (hw->pmd_type  == 'P') {
 372                         /* select page 1 to access Fiber registers */
 373                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 1);
 374
 375                         /* for SFP-module set SIGDET polarity to low */
 376                         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 377                         ctrl |= PHY_M_FIB_SIGD_POL;
 378                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 379                 }
 380
 381                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
 382         }
 383
 384         ctrl = PHY_CT_RESET;
 385         ct1000 = 0;
 386         adv = PHY_AN_CSMA;
 387         reg = 0;
 388
 389         if (sky2->autoneg == AUTONEG_ENABLE) {
 390                 if (sky2_is_copper(hw)) {
 391                         if (sky2->advertising & ADVERTISED_1000baseT_Full)
 392                                 ct1000 |= PHY_M_1000C_AFD;
 393                         if (sky2->advertising & ADVERTISED_1000baseT_Half)
 394                                 ct1000 |= PHY_M_1000C_AHD;
 395                         if (sky2->advertising & ADVERTISED_100baseT_Full)
 396                                 adv |= PHY_M_AN_100_FD;
 397                         if (sky2->advertising & ADVERTISED_100baseT_Half)
 398                                 adv |= PHY_M_AN_100_HD;
 399                         if (sky2->advertising & ADVERTISED_10baseT_Full)
 400                                 adv |= PHY_M_AN_10_FD;
 401                         if (sky2->advertising & ADVERTISED_10baseT_Half)
 402                                 adv |= PHY_M_AN_10_HD;
 403
 404                         adv |= copper_fc_adv[sky2->flow_mode];
 405                 } else {        /* special defines for FIBER (88E1040S only) */
 406                         if (sky2->advertising & ADVERTISED_1000baseT_Full)
 407                                 adv |= PHY_M_AN_1000X_AFD;
 408                         if (sky2->advertising & ADVERTISED_1000baseT_Half)
 409                                 adv |= PHY_M_AN_1000X_AHD;
 410
 411                         adv |= fiber_fc_adv[sky2->flow_mode];
 412                 }
 413
 414                 /* Restart Auto-negotiation */
 415                 ctrl |= PHY_CT_ANE | PHY_CT_RE_CFG;
 416         } else {
 417                 /* forced speed/duplex settings */
 418                 ct1000 = PHY_M_1000C_MSE;
 419
 420                 /* Disable auto update for duplex flow control and speed */
 421                 reg |= GM_GPCR_AU_ALL_DIS;
 422
 423                 switch (sky2->speed) {
 424                 case SPEED_1000:
 425                         ctrl |= PHY_CT_SP1000;
 426                         reg |= GM_GPCR_SPEED_1000;
 427                         break;
 428                 case SPEED_100:
 429                         ctrl |= PHY_CT_SP100;
 430                         reg |= GM_GPCR_SPEED_100;
 431                         break;
 432                 }
 433
 434                 if (sky2->duplex == DUPLEX_FULL) {
 435                         reg |= GM_GPCR_DUP_FULL;
 436                         ctrl |= PHY_CT_DUP_MD;
 437                 } else if (sky2->speed < SPEED_1000)
 438                         sky2->flow_mode = FC_NONE;
 439
 440
 441                 reg |= gm_fc_disable[sky2->flow_mode];
 442
 443                 /* Forward pause packets to GMAC? */
 444                 if (sky2->flow_mode & FC_RX)
 445                         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON);
 446                 else
 447                         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
 448         }
 449
 450         gma_write16(hw, port, GM_GP_CTRL, reg);
 451
 452         if (hw->flags & SKY2_HW_GIGABIT)
 453                 gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, ct1000);
 454
 455         gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, adv);
 456         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
 457
 458         /* Setup Phy LED's */
 459         ledctrl = PHY_M_LED_PULS_DUR(PULS_170MS);
 460         ledover = 0;
 461
 462         switch (hw->chip_id) {
 463         case CHIP_ID_YUKON_FE:
 464                 /* on 88E3082 these bits are at 11..9 (shifted left) */
 465                 ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) << 1;
 466
 467                 ctrl = gm_phy_read(hw, port, PHY_MARV_FE_LED_PAR);
 468
 469                 /* delete ACT LED control bits */
 470                 ctrl &= ~PHY_M_FELP_LED1_MSK;
 471                 /* change ACT LED control to blink mode */
 472                 ctrl |= PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_ACT_BL);
 473                 gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl);
 474                 break;
 475
 476         case CHIP_ID_YUKON_FE_P:
 477                 /* Enable Link Partner Next Page */
 478                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 479                 ctrl |= PHY_M_PC_ENA_LIP_NP;
 480
 481                 /* disable Energy Detect and enable scrambler */
 482                 ctrl &= ~(PHY_M_PC_ENA_ENE_DT | PHY_M_PC_DIS_SCRAMB);
 483                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 484
 485                 /* set LED2 -> ACT, LED1 -> LINK, LED0 -> SPEED */
 486                 ctrl = PHY_M_FELP_LED2_CTRL(LED_PAR_CTRL_ACT_BL) |
 487                         PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_LINK) |
 488                         PHY_M_FELP_LED0_CTRL(LED_PAR_CTRL_SPEED);
 489
 490                 gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl);
 491                 break;
 492
 493         case CHIP_ID_YUKON_XL:
 494                 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
 495
 496                 /* select page 3 to access LED control register */
 497                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3);
 498
 499                 /* set LED Function Control register */
 500                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL,
 501                              (PHY_M_LEDC_LOS_CTRL(1) |  /* LINK/ACT */
 502                               PHY_M_LEDC_INIT_CTRL(7) | /* 10 Mbps */
 503                               PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
 504                               PHY_M_LEDC_STA0_CTRL(7)));        /* 1000 Mbps */
 505
 506                 /* set Polarity Control register */
 507                 gm_phy_write(hw, port, PHY_MARV_PHY_STAT,
 508                              (PHY_M_POLC_LS1_P_MIX(4) |
 509                               PHY_M_POLC_IS0_P_MIX(4) |
 510                               PHY_M_POLC_LOS_CTRL(2) |
 511                               PHY_M_POLC_INIT_CTRL(2) |
 512                               PHY_M_POLC_STA1_CTRL(2) |
 513                               PHY_M_POLC_STA0_CTRL(2)));
 514
 515                 /* restore page register */
 516                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
 517                 break;
 518
 519         case CHIP_ID_YUKON_EC_U:
 520         case CHIP_ID_YUKON_EX:
 521         case CHIP_ID_YUKON_SUPR:
 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(8) | /* 10 Mbps */
 531                               PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */
 532                               PHY_M_LEDC_STA0_CTRL(7)));/* 1000 Mbps */
 533
 534                 /* set Blink Rate in LED Timer Control Register */
 535                 gm_phy_write(hw, port, PHY_MARV_INT_MASK,
 536                              ledctrl | PHY_M_LED_BLINK_RT(BLINK_84MS));
 537                 /* restore page register */
 538                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
 539                 break;
 540
 541         default:
 542                 /* set Tx LED (LED_TX) to blink mode on Rx OR Tx activity */
 543                 ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) | PHY_M_LEDC_TX_CTRL;
 544
 545                 /* turn off the Rx LED (LED_RX) */
 546                 ledover |= PHY_M_LED_MO_RX(MO_LED_OFF);
 547         }
 548
 549         if (hw->chip_id == CHIP_ID_YUKON_EC_U || hw->chip_id == CHIP_ID_YUKON_UL_2) {
 550                 /* apply fixes in PHY AFE */
 551                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 255);
 552
 553                 /* increase differential signal amplitude in 10BASE-T */
 554                 gm_phy_write(hw, port, 0x18, 0xaa99);
 555                 gm_phy_write(hw, port, 0x17, 0x2011);
 556
 557                 if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
 558                         /* fix for IEEE A/B Symmetry failure in 1000BASE-T */
 559                         gm_phy_write(hw, port, 0x18, 0xa204);
 560                         gm_phy_write(hw, port, 0x17, 0x2002);
 561                 }
 562
 563                 /* set page register to 0 */
 564                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
 565         } else if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
 566                    hw->chip_rev == CHIP_REV_YU_FE2_A0) {
 567                 /* apply workaround for integrated resistors calibration */
 568                 gm_phy_write(hw, port, PHY_MARV_PAGE_ADDR, 17);
 569                 gm_phy_write(hw, port, PHY_MARV_PAGE_DATA, 0x3f60);
 570         } else if (hw->chip_id != CHIP_ID_YUKON_EX &&
 571                    hw->chip_id < CHIP_ID_YUKON_SUPR) {
 572                 /* no effect on Yukon-XL */
 573                 gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
 574
 575                 if (sky2->autoneg == AUTONEG_DISABLE || sky2->speed == SPEED_100) {
 576                         /* turn on 100 Mbps LED (LED_LINK100) */
 577                         ledover |= PHY_M_LED_MO_100(MO_LED_ON);
 578                 }
 579
 580                 if (ledover)
 581                         gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover);
 582
 583         }
 584
 585         /* Enable phy interrupt on auto-negotiation complete (or link up) */
 586         if (sky2->autoneg == AUTONEG_ENABLE)
 587                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_COMPL);
 588         else
 589                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK);
 590 }
 591
 592 static const u32 phy_power[] = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
 593 static const u32 coma_mode[] = { PCI_Y2_PHY1_COMA, PCI_Y2_PHY2_COMA };
 594
 595 static void sky2_phy_power_up(struct sky2_hw *hw, unsigned port)
 596 {
 597         u32 reg1;
 598
 599         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
 600         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
 601         reg1 &= ~phy_power[port];
 602
 603         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
 604                 reg1 |= coma_mode[port];
 605
 606         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
 607         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 608         sky2_pci_read32(hw, PCI_DEV_REG1);
 609
 610         if (hw->chip_id == CHIP_ID_YUKON_FE)
 611                 gm_phy_write(hw, port, PHY_MARV_CTRL, PHY_CT_ANE);
 612         else if (hw->flags & SKY2_HW_ADV_POWER_CTL)
 613                 sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
 614 }
 615
 616 static void sky2_phy_power_down(struct sky2_hw *hw, unsigned port)
 617 {
 618         u32 reg1;
 619         u16 ctrl;
 620
 621         /* release GPHY Control reset */
 622         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
 623
 624         /* release GMAC reset */
 625         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR);
 626
 627         if (hw->flags & SKY2_HW_NEWER_PHY) {
 628                 /* select page 2 to access MAC control register */
 629                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
 630
 631                 ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 632                 /* allow GMII Power Down */
 633                 ctrl &= ~PHY_M_MAC_GMIF_PUP;
 634                 gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 635
 636                 /* set page register back to 0 */
 637                 gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
 638         }
 639
 640         /* setup General Purpose Control Register */
 641         gma_write16(hw, port, GM_GP_CTRL,
 642                     GM_GPCR_FL_PASS | GM_GPCR_SPEED_100 | GM_GPCR_AU_ALL_DIS);
 643
 644         if (hw->chip_id != CHIP_ID_YUKON_EC) {
 645                 if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
 646                         /* select page 2 to access MAC control register */
 647                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2);
 648
 649                         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
 650                         /* enable Power Down */
 651                         ctrl |= PHY_M_PC_POW_D_ENA;
 652                         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
 653
 654                         /* set page register back to 0 */
 655                         gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
 656                 }
 657
 658                 /* set IEEE compatible Power Down Mode (dev. #4.99) */
 659                 gm_phy_write(hw, port, PHY_MARV_CTRL, PHY_CT_PDOWN);
 660         }
 661
 662         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
 663         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
 664         reg1 |= phy_power[port];                /* set PHY to PowerDown/COMA Mode */
 665         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
 666         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 667 }
 668
 669 static void sky2_set_tx_stfwd(struct sky2_hw *hw, unsigned port)
 670 {
 671         if ( (hw->chip_id == CHIP_ID_YUKON_EX &&
 672               hw->chip_rev != CHIP_REV_YU_EX_A0) ||
 673              hw->chip_id == CHIP_ID_YUKON_FE_P ||
 674              hw->chip_id == CHIP_ID_YUKON_SUPR) {
 675                 /* disable jumbo frames on devices that support them */
 676                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T),
 677                              TX_JUMBO_DIS | TX_STFW_ENA);
 678         } else {
 679                 sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_STFW_ENA);
 680         }
 681 }
 682
 683 static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 684 {
 685         u16 reg;
 686         u32 rx_reg;
 687         int i;
 688         const u8 *addr = hw->dev[port]->ll_addr;
 689
 690         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
 691         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR);
 692
 693         sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR);
 694
 695         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 && port == 1) {
 696                 /* WA DEV_472 -- looks like crossed wires on port 2 */
 697                 /* clear GMAC 1 Control reset */
 698                 sky2_write8(hw, SK_REG(0, GMAC_CTRL), GMC_RST_CLR);
 699                 do {
 700                         sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_SET);
 701                         sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_CLR);
 702                 } while (gm_phy_read(hw, 1, PHY_MARV_ID0) != PHY_MARV_ID0_VAL ||
 703                          gm_phy_read(hw, 1, PHY_MARV_ID1) != PHY_MARV_ID1_Y2 ||
 704                          gm_phy_read(hw, 1, PHY_MARV_INT_MASK) != 0);
 705         }
 706
 707         sky2_read16(hw, SK_REG(port, GMAC_IRQ_SRC));
 708
 709         /* Enable Transmit FIFO Underrun */
 710         sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), GMAC_DEF_MSK);
 711
 712         sky2_phy_power_up(hw, port);
 713         sky2_phy_init(hw, port);
 714
 715         /* MIB clear */
 716         reg = gma_read16(hw, port, GM_PHY_ADDR);
 717         gma_write16(hw, port, GM_PHY_ADDR, reg | GM_PAR_MIB_CLR);
 718
 719         for (i = GM_MIB_CNT_BASE; i <= GM_MIB_CNT_END; i += 4)
 720                 gma_read16(hw, port, i);
 721         gma_write16(hw, port, GM_PHY_ADDR, reg);
 722
 723         /* transmit control */
 724         gma_write16(hw, port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF));
 725
 726         /* receive control reg: unicast + multicast + no FCS  */
 727         gma_write16(hw, port, GM_RX_CTRL,
 728                     GM_RXCR_UCF_ENA | GM_RXCR_CRC_DIS | GM_RXCR_MCF_ENA);
 729
 730         /* transmit flow control */
 731         gma_write16(hw, port, GM_TX_FLOW_CTRL, 0xffff);
 732
 733         /* transmit parameter */
 734         gma_write16(hw, port, GM_TX_PARAM,
 735                     TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) |
 736                     TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) |
 737                     TX_IPG_JAM_DATA(TX_IPG_JAM_DEF) |
 738                     TX_BACK_OFF_LIM(TX_BOF_LIM_DEF));
 739
 740         /* serial mode register */
 741         reg = DATA_BLIND_VAL(DATA_BLIND_DEF) |
 742                 GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
 743
 744         gma_write16(hw, port, GM_SERIAL_MODE, reg);
 745
 746         /* virtual address for data */
 747         gma_set_addr(hw, port, GM_SRC_ADDR_2L, addr);
 748
 749         /* physical address: used for pause frames */
 750         gma_set_addr(hw, port, GM_SRC_ADDR_1L, addr);
 751
 752         /* ignore counter overflows */
 753         gma_write16(hw, port, GM_TX_IRQ_MSK, 0);
 754         gma_write16(hw, port, GM_RX_IRQ_MSK, 0);
 755         gma_write16(hw, port, GM_TR_IRQ_MSK, 0);
 756
 757         /* Configure Rx MAC FIFO */
 758         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR);
 759         rx_reg = GMF_OPER_ON | GMF_RX_F_FL_ON;
 760         if (hw->chip_id == CHIP_ID_YUKON_EX ||
 761             hw->chip_id == CHIP_ID_YUKON_FE_P)
 762                 rx_reg |= GMF_RX_OVER_ON;
 763
 764         sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), rx_reg);
 765
 766         if (hw->chip_id == CHIP_ID_YUKON_XL) {
 767                 /* Hardware errata - clear flush mask */
 768                 sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), 0);
 769         } else {
 770                 /* Flush Rx MAC FIFO on any flow control or error */
 771                 sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR);
 772         }
 773
 774         /* Set threshold to 0xa (64 bytes) + 1 to workaround pause bug  */
 775         reg = RX_GMF_FL_THR_DEF + 1;
 776         /* Another magic mystery workaround from sk98lin */
 777         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
 778             hw->chip_rev == CHIP_REV_YU_FE2_A0)
 779                 reg = 0x178;
 780         sky2_write16(hw, SK_REG(port, RX_GMF_FL_THR), reg);
 781
 782         /* Configure Tx MAC FIFO */
 783         sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_CLR);
 784         sky2_write16(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_OPER_ON);
 785
 786         /* On chips without ram buffer, pause is controlled by MAC level */
 787         if (!(hw->flags & SKY2_HW_RAM_BUFFER)) {
 788                 sky2_write8(hw, SK_REG(port, RX_GMF_LP_THR), 768/8);
 789                 sky2_write8(hw, SK_REG(port, RX_GMF_UP_THR), 1024/8);
 790
 791                 sky2_set_tx_stfwd(hw, port);
 792         }
 793
 794         if (hw->chip_id == CHIP_ID_YUKON_FE_P &&
 795             hw->chip_rev == CHIP_REV_YU_FE2_A0) {
 796                 /* disable dynamic watermark */
 797                 reg = sky2_read16(hw, SK_REG(port, TX_GMF_EA));
 798                 reg &= ~TX_DYN_WM_ENA;
 799                 sky2_write16(hw, SK_REG(port, TX_GMF_EA), reg);
 800         }
 801 }
 802
 803 /* Assign Ram Buffer allocation to queue */
 804 static void sky2_ramset(struct sky2_hw *hw, u16 q, u32 start, u32 space)
 805 {
 806         u32 end;
 807
 808         /* convert from K bytes to qwords used for hw register */
 809         start *= 1024/8;
 810         space *= 1024/8;
 811         end = start + space - 1;
 812
 813         sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR);
 814         sky2_write32(hw, RB_ADDR(q, RB_START), start);
 815         sky2_write32(hw, RB_ADDR(q, RB_END), end);
 816         sky2_write32(hw, RB_ADDR(q, RB_WP), start);
 817         sky2_write32(hw, RB_ADDR(q, RB_RP), start);
 818
 819         if (q == Q_R1 || q == Q_R2) {
 820                 u32 tp = space - space/4;
 821
 822                 /* On receive queue's set the thresholds
 823                  * give receiver priority when > 3/4 full
 824                  * send pause when down to 2K
 825                  */
 826                 sky2_write32(hw, RB_ADDR(q, RB_RX_UTHP), tp);
 827                 sky2_write32(hw, RB_ADDR(q, RB_RX_LTHP), space/2);
 828
 829                 tp = space - 2048/8;
 830                 sky2_write32(hw, RB_ADDR(q, RB_RX_UTPP), tp);
 831                 sky2_write32(hw, RB_ADDR(q, RB_RX_LTPP), space/4);
 832         } else {
 833                 /* Enable store & forward on Tx queue's because
 834                  * Tx FIFO is only 1K on Yukon
 835                  */
 836                 sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_STFWD);
 837         }
 838
 839         sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_OP_MD);
 840         sky2_read8(hw, RB_ADDR(q, RB_CTRL));
 841 }
 842
 843 /* Setup Bus Memory Interface */
 844 static void sky2_qset(struct sky2_hw *hw, u16 q)
 845 {
 846         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_RESET);
 847         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_OPER_INIT);
 848         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_FIFO_OP_ON);
 849         sky2_write32(hw, Q_ADDR(q, Q_WM),  BMU_WM_DEFAULT);
 850 }
 851
 852 /* Setup prefetch unit registers. This is the interface between
 853  * hardware and driver list elements
 854  */
 855 static void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr,
 856                                       u64 addr, u32 last)
 857 {
 858         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
 859         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_CLR);
 860         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), addr >> 32);
 861         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), (u32) addr);
 862         sky2_write16(hw, Y2_QADDR(qaddr, PREF_UNIT_LAST_IDX), last);
 863         sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_OP_ON);
 864
 865         sky2_read32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL));
 866 }
 867
 868 static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2)
 869 {
 870         struct sky2_tx_le *le = sky2->tx_le + sky2->tx_prod;
 871
 872         sky2->tx_prod = RING_NEXT(sky2->tx_prod, TX_RING_SIZE);
 873         le->ctrl = 0;
 874         return le;
 875 }
 876
 877 static void tx_init(struct sky2_port *sky2)
 878 {
 879         struct sky2_tx_le *le;
 880
 881         sky2->tx_prod = sky2->tx_cons = 0;
 882
 883         le = get_tx_le(sky2);
 884         le->addr = 0;
 885         le->opcode = OP_ADDR64 | HW_OWNER;
 886 }
 887
 888 static inline struct tx_ring_info *tx_le_re(struct sky2_port *sky2,
 889                                             struct sky2_tx_le *le)
 890 {
 891         return sky2->tx_ring + (le - sky2->tx_le);
 892 }
 893
 894 /* Update chip's next pointer */
 895 static inline void sky2_put_idx(struct sky2_hw *hw, unsigned q, u16 idx)
 896 {
 897         /* Make sure write' to descriptors are complete before we tell hardware */
 898         wmb();
 899         sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), idx);
 900         DBGIO(PFX "queue %#x idx <- %d\n", q, idx);
 901 }
 902
 903
 904 static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2)
 905 {
 906         struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put;
 907
 908         sky2->rx_put = RING_NEXT(sky2->rx_put, RX_LE_SIZE);
 909         le->ctrl = 0;
 910         return le;
 911 }
 912
 913 /* Build description to hardware for one receive segment */
 914 static void sky2_rx_add(struct sky2_port *sky2,  u8 op,
 915                         u32 map, unsigned len)
 916 {
 917         struct sky2_rx_le *le;
 918
 919         le = sky2_next_rx(sky2);
 920         le->addr = cpu_to_le32(map);
 921         le->length = cpu_to_le16(len);
 922         le->opcode = op | HW_OWNER;
 923 }
 924
 925 /* Build description to hardware for one possibly fragmented skb */
 926 static void sky2_rx_submit(struct sky2_port *sky2,
 927                            const struct rx_ring_info *re)
 928 {
 929         sky2_rx_add(sky2, OP_PACKET, re->data_addr, sky2->rx_data_size);
 930 }
 931
 932
 933 static void sky2_rx_map_iob(struct pci_device *pdev __unused,
 934                             struct rx_ring_info *re,
 935                             unsigned size __unused)
 936 {
 937         struct io_buffer *iob = re->iob;
 938         re->data_addr = virt_to_bus(iob->data);
 939 }
 940
 941 /* Diable the checksum offloading.
 942  */
 943 static void rx_set_checksum(struct sky2_port *sky2)
 944 {
 945         struct sky2_rx_le *le = sky2_next_rx(sky2);
 946
 947         le->addr = cpu_to_le32((ETH_HLEN << 16) | ETH_HLEN);
 948         le->ctrl = 0;
 949         le->opcode = OP_TCPSTART | HW_OWNER;
 950
 951         sky2_write32(sky2->hw,
 952                      Q_ADDR(rxqaddr[sky2->port], Q_CSR),
 953                      BMU_DIS_RX_CHKSUM);
 954 }
 955
 956 /*
 957  * The RX Stop command will not work for Yukon-2 if the BMU does not
 958  * reach the end of packet and since we can't make sure that we have
 959  * incoming data, we must reset the BMU while it is not doing a DMA
 960  * transfer. Since it is possible that the RX path is still active,
 961  * the RX RAM buffer will be stopped first, so any possible incoming
 962  * data will not trigger a DMA. After the RAM buffer is stopped, the
 963  * BMU is polled until any DMA in progress is ended and only then it
 964  * will be reset.
 965  */
 966 static void sky2_rx_stop(struct sky2_port *sky2)
 967 {
 968         struct sky2_hw *hw = sky2->hw;
 969         unsigned rxq = rxqaddr[sky2->port];
 970         int i;
 971
 972         /* disable the RAM Buffer receive queue */
 973         sky2_write8(hw, RB_ADDR(rxq, RB_CTRL), RB_DIS_OP_MD);
 974
 975         for (i = 0; i < 0xffff; i++)
 976                 if (sky2_read8(hw, RB_ADDR(rxq, Q_RSL))
 977                     == sky2_read8(hw, RB_ADDR(rxq, Q_RL)))
 978                         goto stopped;
 979
 980         DBG(PFX "%s: receiver stop failed\n", sky2->netdev->name);
 981 stopped:
 982         sky2_write32(hw, Q_ADDR(rxq, Q_CSR), BMU_RST_SET | BMU_FIFO_RST);
 983
 984         /* reset the Rx prefetch unit */
 985         sky2_write32(hw, Y2_QADDR(rxq, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
 986         wmb();
 987 }
 988
 989 /* Clean out receive buffer area, assumes receiver hardware stopped */
 990 static void sky2_rx_clean(struct sky2_port *sky2)
 991 {
 992         unsigned i;
 993
 994         memset(sky2->rx_le, 0, RX_LE_BYTES);
 995         for (i = 0; i < RX_PENDING; i++) {
 996                 struct rx_ring_info *re = sky2->rx_ring + i;
 997
 998                 if (re->iob) {
 999                         free_iob(re->iob);
1000                         re->iob = NULL;
1001                 }
1002         }
1003 }
1004
1005 /*
1006  * Allocate an iob for receiving.
1007  */
1008 static struct io_buffer *sky2_rx_alloc(struct sky2_port *sky2)
1009 {
1010         struct io_buffer *iob;
1011
1012         iob = alloc_iob(sky2->rx_data_size + ETH_DATA_ALIGN);
1013         if (!iob)
1014                 return NULL;
1015
1016         /*
1017          * Cards with a RAM buffer hang in the rx FIFO if the
1018          * receive buffer isn't aligned to (Linux module comments say
1019          * 64 bytes, Linux module code says 8 bytes). Since io_buffers
1020          * are always 2kb-aligned under iPXE, just leave it be
1021          * without ETH_DATA_ALIGN in those cases.
1022          *
1023          * XXX This causes unaligned access to the IP header,
1024          * which is undesirable, but it's less undesirable than the
1025          * card hanging.
1026          */
1027         if (!(sky2->hw->flags & SKY2_HW_RAM_BUFFER)) {
1028                 iob_reserve(iob, ETH_DATA_ALIGN);
1029         }
1030
1031         return iob;
1032 }
1033
1034 static inline void sky2_rx_update(struct sky2_port *sky2, unsigned rxq)
1035 {
1036         sky2_put_idx(sky2->hw, rxq, sky2->rx_put);
1037 }
1038
1039 /*
1040  * Allocate and setup receiver buffer pool.
1041  * Normal case this ends up creating one list element for skb
1042  * in the receive ring. One element is used for checksum
1043  * enable/disable, and one extra to avoid wrap.
1044  */
1045 static int sky2_rx_start(struct sky2_port *sky2)
1046 {
1047         struct sky2_hw *hw = sky2->hw;
1048         struct rx_ring_info *re;
1049         unsigned rxq = rxqaddr[sky2->port];
1050         unsigned i, size, thresh;
1051
1052         sky2->rx_put = sky2->rx_next = 0;
1053         sky2_qset(hw, rxq);
1054
1055         /* On PCI express lowering the watermark gives better performance */
1056         if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP))
1057                 sky2_write32(hw, Q_ADDR(rxq, Q_WM), BMU_WM_PEX);
1058
1059         /* These chips have no ram buffer?
1060          * MAC Rx RAM Read is controlled by hardware */
1061         if (hw->chip_id == CHIP_ID_YUKON_EC_U &&
1062             (hw->chip_rev == CHIP_REV_YU_EC_U_A1
1063              || hw->chip_rev == CHIP_REV_YU_EC_U_B0))
1064                 sky2_write32(hw, Q_ADDR(rxq, Q_TEST), F_M_RX_RAM_DIS);
1065
1066         sky2_prefetch_init(hw, rxq, sky2->rx_le_map, RX_LE_SIZE - 1);
1067
1068         if (!(hw->flags & SKY2_HW_NEW_LE))
1069                 rx_set_checksum(sky2);
1070
1071         /* Space needed for frame data + headers rounded up */
1072         size = (ETH_FRAME_LEN + 8) & ~7;
1073
1074         /* Stopping point for hardware truncation */
1075         thresh = (size - 8) / sizeof(u32);
1076
1077         sky2->rx_data_size = size;
1078
1079         /* Fill Rx ring */
1080         for (i = 0; i < RX_PENDING; i++) {
1081                 re = sky2->rx_ring + i;
1082
1083                 re->iob = sky2_rx_alloc(sky2);
1084                 if (!re->iob)
1085                         goto nomem;
1086
1087                 sky2_rx_map_iob(hw->pdev, re, sky2->rx_data_size);
1088                 sky2_rx_submit(sky2, re);
1089         }
1090
1091         /*
1092          * The receiver hangs if it receives frames larger than the
1093          * packet buffer. As a workaround, truncate oversize frames, but
1094          * the register is limited to 9 bits, so if you do frames > 2052
1095          * you better get the MTU right!
1096          */
1097         if (thresh > 0x1ff)
1098                 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_OFF);
1099         else {
1100                 sky2_write16(hw, SK_REG(sky2->port, RX_GMF_TR_THR), thresh);
1101                 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_ON);
1102         }
1103
1104         /* Tell chip about available buffers */
1105         sky2_rx_update(sky2, rxq);
1106         return 0;
1107 nomem:
1108         sky2_rx_clean(sky2);
1109         return -ENOMEM;
1110 }
1111
1112 /* Free the le and ring buffers */
1113 static void sky2_free_rings(struct sky2_port *sky2)
1114 {
1115         free_dma(sky2->rx_le, RX_LE_BYTES);
1116         free(sky2->rx_ring);
1117
1118         free_dma(sky2->tx_le, TX_RING_SIZE * sizeof(struct sky2_tx_le));
1119         free(sky2->tx_ring);
1120
1121         sky2->tx_le = NULL;
1122         sky2->rx_le = NULL;
1123
1124         sky2->rx_ring = NULL;
1125         sky2->tx_ring = NULL;
1126 }
1127
1128 /* Bring up network interface. */
1129 static int sky2_up(struct net_device *dev)
1130 {
1131         struct sky2_port *sky2 = netdev_priv(dev);
1132         struct sky2_hw *hw = sky2->hw;
1133         unsigned port = sky2->port;
1134         u32 imask, ramsize;
1135         int err = -ENOMEM;
1136
1137         netdev_link_down(dev);
1138
1139         /* must be power of 2 */
1140         sky2->tx_le = malloc_dma(TX_RING_SIZE * sizeof(struct sky2_tx_le), TX_RING_ALIGN);
1141         sky2->tx_le_map = virt_to_bus(sky2->tx_le);
1142         if (!sky2->tx_le)
1143                 goto err_out;
1144         memset(sky2->tx_le, 0, TX_RING_SIZE * sizeof(struct sky2_tx_le));
1145
1146         sky2->tx_ring = zalloc(TX_RING_SIZE * sizeof(struct tx_ring_info));
1147         if (!sky2->tx_ring)
1148                 goto err_out;
1149
1150         tx_init(sky2);
1151
1152         sky2->rx_le = malloc_dma(RX_LE_BYTES, RX_RING_ALIGN);
1153         sky2->rx_le_map = virt_to_bus(sky2->rx_le);
1154         if (!sky2->rx_le)
1155                 goto err_out;
1156         memset(sky2->rx_le, 0, RX_LE_BYTES);
1157
1158         sky2->rx_ring = zalloc(RX_PENDING * sizeof(struct rx_ring_info));
1159         if (!sky2->rx_ring)
1160                 goto err_out;
1161
1162         sky2_mac_init(hw, port);
1163
1164         /* Register is number of 4K blocks on internal RAM buffer. */
1165         ramsize = sky2_read8(hw, B2_E_0) * 4;
1166         if (ramsize > 0) {
1167                 u32 rxspace;
1168
1169                 hw->flags |= SKY2_HW_RAM_BUFFER;
1170                 DBG2(PFX "%s: ram buffer %dK\n", dev->name, ramsize);
1171                 if (ramsize < 16)
1172                         rxspace = ramsize / 2;
1173                 else
1174                         rxspace = 8 + (2*(ramsize - 16))/3;
1175
1176                 sky2_ramset(hw, rxqaddr[port], 0, rxspace);
1177                 sky2_ramset(hw, txqaddr[port], rxspace, ramsize - rxspace);
1178
1179                 /* Make sure SyncQ is disabled */
1180                 sky2_write8(hw, RB_ADDR(port == 0 ? Q_XS1 : Q_XS2, RB_CTRL),
1181                             RB_RST_SET);
1182         }
1183
1184         sky2_qset(hw, txqaddr[port]);
1185
1186         /* This is copied from sk98lin 10.0.5.3; no one tells me about erratta's */
1187         if (hw->chip_id == CHIP_ID_YUKON_EX && hw->chip_rev == CHIP_REV_YU_EX_B0)
1188                 sky2_write32(hw, Q_ADDR(txqaddr[port], Q_TEST), F_TX_CHK_AUTO_OFF);
1189
1190         /* Set almost empty threshold */
1191         if (hw->chip_id == CHIP_ID_YUKON_EC_U
1192             && hw->chip_rev == CHIP_REV_YU_EC_U_A0)
1193                 sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), ECU_TXFF_LEV);
1194
1195         sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map,
1196                            TX_RING_SIZE - 1);
1197
1198         err = sky2_rx_start(sky2);
1199         if (err)
1200                 goto err_out;
1201
1202         /* Enable interrupts from phy/mac for port */
1203         imask = sky2_read32(hw, B0_IMSK);
1204         imask |= portirq_msk[port];
1205         sky2_write32(hw, B0_IMSK, imask);
1206
1207         DBGIO(PFX "%s: le bases: st %p [%x], rx %p [%x], tx %p [%x]\n",
1208               dev->name, hw->st_le, hw->st_dma, sky2->rx_le, sky2->rx_le_map,
1209               sky2->tx_le, sky2->tx_le_map);
1210
1211         sky2_set_multicast(dev);
1212         return 0;
1213
1214 err_out:
1215         sky2_free_rings(sky2);
1216         return err;
1217 }
1218
1219 /* Modular subtraction in ring */
1220 static inline int tx_dist(unsigned tail, unsigned head)
1221 {
1222         return (head - tail) & (TX_RING_SIZE - 1);
1223 }
1224
1225 /* Number of list elements available for next tx */
1226 static inline int tx_avail(const struct sky2_port *sky2)
1227 {
1228         return TX_PENDING - tx_dist(sky2->tx_cons, sky2->tx_prod);
1229 }
1230
1231
1232 /*
1233  * Put one packet in ring for transmit.
1234  * A single packet can generate multiple list elements, and
1235  * the number of ring elements will probably be less than the number
1236  * of list elements used.
1237  */
1238 static int sky2_xmit_frame(struct net_device *dev, struct io_buffer *iob)
1239 {
1240         struct sky2_port *sky2 = netdev_priv(dev);
1241         struct sky2_hw *hw = sky2->hw;
1242         struct sky2_tx_le *le = NULL;
1243         struct tx_ring_info *re;
1244         unsigned len;
1245         u32 mapping;
1246         u8 ctrl;
1247
1248         if (tx_avail(sky2) < 1)
1249                 return -EBUSY;
1250
1251         len = iob_len(iob);
1252         mapping = virt_to_bus(iob->data);
1253
1254         DBGIO(PFX "%s: tx queued, slot %d, len %d\n", dev->name,
1255               sky2->tx_prod, len);
1256
1257         ctrl = 0;
1258
1259         le = get_tx_le(sky2);
1260         le->addr = cpu_to_le32((u32) mapping);
1261         le->length = cpu_to_le16(len);
1262         le->ctrl = ctrl;
1263         le->opcode = (OP_PACKET | HW_OWNER);
1264
1265         re = tx_le_re(sky2, le);
1266         re->iob = iob;
1267
1268         le->ctrl |= EOP;
1269
1270         sky2_put_idx(hw, txqaddr[sky2->port], sky2->tx_prod);
1271
1272         return 0;
1273 }
1274
1275 /*
1276  * Free ring elements from starting at tx_cons until "done"
1277  *
1278  * NB: the hardware will tell us about partial completion of multi-part
1279  *     buffers so make sure not to free iob too early.
1280  */
1281 static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
1282 {
1283         struct net_device *dev = sky2->netdev;
1284         unsigned idx;
1285
1286         assert(done < TX_RING_SIZE);
1287
1288         for (idx = sky2->tx_cons; idx != done;
1289              idx = RING_NEXT(idx, TX_RING_SIZE)) {
1290                 struct sky2_tx_le *le = sky2->tx_le + idx;
1291                 struct tx_ring_info *re = sky2->tx_ring + idx;
1292
1293                 if (le->ctrl & EOP) {
1294                         DBGIO(PFX "%s: tx done %d\n", dev->name, idx);
1295                         netdev_tx_complete(dev, re->iob);
1296                 }
1297         }
1298
1299         sky2->tx_cons = idx;
1300         mb();
1301 }
1302
1303 /* Cleanup all untransmitted buffers, assume transmitter not running */
1304 static void sky2_tx_clean(struct net_device *dev)
1305 {
1306         struct sky2_port *sky2 = netdev_priv(dev);
1307
1308         sky2_tx_complete(sky2, sky2->tx_prod);
1309 }
1310
1311 /* Network shutdown */
1312 static void sky2_down(struct net_device *dev)
1313 {
1314         struct sky2_port *sky2 = netdev_priv(dev);
1315         struct sky2_hw *hw = sky2->hw;
1316         unsigned port = sky2->port;
1317         u16 ctrl;
1318         u32 imask;
1319
1320         /* Never really got started! */
1321         if (!sky2->tx_le)
1322                 return;
1323
1324         DBG2(PFX "%s: disabling interface\n", dev->name);
1325
1326         /* Disable port IRQ */
1327         imask = sky2_read32(hw, B0_IMSK);
1328         imask &= ~portirq_msk[port];
1329         sky2_write32(hw, B0_IMSK, imask);
1330
1331         sky2_gmac_reset(hw, port);
1332
1333         /* Stop transmitter */
1334         sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_STOP);
1335         sky2_read32(hw, Q_ADDR(txqaddr[port], Q_CSR));
1336
1337         sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL),
1338                      RB_RST_SET | RB_DIS_OP_MD);
1339
1340         ctrl = gma_read16(hw, port, GM_GP_CTRL);
1341         ctrl &= ~(GM_GPCR_TX_ENA | GM_GPCR_RX_ENA);
1342         gma_write16(hw, port, GM_GP_CTRL, ctrl);
1343
1344         sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
1345
1346         /* Workaround shared GMAC reset */
1347         if (!(hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0
1348               && port == 0 && hw->dev[1]))
1349                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET);
1350
1351         /* Disable Force Sync bit and Enable Alloc bit */
1352         sky2_write8(hw, SK_REG(port, TXA_CTRL),
1353                     TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
1354
1355         /* Stop Interval Timer and Limit Counter of Tx Arbiter */
1356         sky2_write32(hw, SK_REG(port, TXA_ITI_INI), 0L);
1357         sky2_write32(hw, SK_REG(port, TXA_LIM_INI), 0L);
1358
1359         /* Reset the PCI FIFO of the async Tx queue */
1360         sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR),
1361                      BMU_RST_SET | BMU_FIFO_RST);
1362
1363         /* Reset the Tx prefetch units */
1364         sky2_write32(hw, Y2_QADDR(txqaddr[port], PREF_UNIT_CTRL),
1365                      PREF_UNIT_RST_SET);
1366
1367         sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), RB_RST_SET);
1368
1369         sky2_rx_stop(sky2);
1370
1371         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET);
1372         sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET);
1373
1374         sky2_phy_power_down(hw, port);
1375
1376         /* turn off LED's */
1377         sky2_write16(hw, B0_Y2LED, LED_STAT_OFF);
1378
1379         sky2_tx_clean(dev);
1380         sky2_rx_clean(sky2);
1381
1382         sky2_free_rings(sky2);
1383
1384         return;
1385 }
1386
1387 static u16 sky2_phy_speed(const struct sky2_hw *hw, u16 aux)
1388 {
1389         if (hw->flags & SKY2_HW_FIBRE_PHY)
1390                 return SPEED_1000;
1391
1392         if (!(hw->flags & SKY2_HW_GIGABIT)) {
1393                 if (aux & PHY_M_PS_SPEED_100)
1394                         return SPEED_100;
1395                 else
1396                         return SPEED_10;
1397         }
1398
1399         switch (aux & PHY_M_PS_SPEED_MSK) {
1400         case PHY_M_PS_SPEED_1000:
1401                 return SPEED_1000;
1402         case PHY_M_PS_SPEED_100:
1403                 return SPEED_100;
1404         default:
1405                 return SPEED_10;
1406         }
1407 }
1408
1409 static void sky2_link_up(struct sky2_port *sky2)
1410 {
1411         struct sky2_hw *hw = sky2->hw;
1412         unsigned port = sky2->port;
1413         u16 reg;
1414         static const char *fc_name[] = {
1415                 [FC_NONE]       = "none",
1416                 [FC_TX]         = "tx",
1417                 [FC_RX]         = "rx",
1418                 [FC_BOTH]       = "both",
1419         };
1420
1421         /* enable Rx/Tx */
1422         reg = gma_read16(hw, port, GM_GP_CTRL);
1423         reg |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA;
1424         gma_write16(hw, port, GM_GP_CTRL, reg);
1425
1426         gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK);
1427
1428         netdev_link_up(sky2->netdev);
1429
1430         /* Turn on link LED */
1431         sky2_write8(hw, SK_REG(port, LNK_LED_REG),
1432                     LINKLED_ON | LINKLED_BLINK_OFF | LINKLED_LINKSYNC_OFF);
1433
1434         DBG(PFX "%s: Link is up at %d Mbps, %s duplex, flow control %s\n",
1435             sky2->netdev->name, sky2->speed,
1436             sky2->duplex == DUPLEX_FULL ? "full" : "half",
1437             fc_name[sky2->flow_status]);
1438 }
1439
1440 static void sky2_link_down(struct sky2_port *sky2)
1441 {
1442         struct sky2_hw *hw = sky2->hw;
1443         unsigned port = sky2->port;
1444         u16 reg;
1445
1446         gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0);
1447
1448         reg = gma_read16(hw, port, GM_GP_CTRL);
1449         reg &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
1450         gma_write16(hw, port, GM_GP_CTRL, reg);
1451
1452         netdev_link_down(sky2->netdev);
1453
1454         /* Turn on link LED */
1455         sky2_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF);
1456
1457         DBG(PFX "%s: Link is down.\n", sky2->netdev->name);
1458
1459         sky2_phy_init(hw, port);
1460 }
1461
1462 static int sky2_autoneg_done(struct sky2_port *sky2, u16 aux)
1463 {
1464         struct sky2_hw *hw = sky2->hw;
1465         unsigned port = sky2->port;
1466         u16 advert, lpa;
1467
1468         advert = gm_phy_read(hw, port, PHY_MARV_AUNE_ADV);
1469         lpa = gm_phy_read(hw, port, PHY_MARV_AUNE_LP);
1470         if (lpa & PHY_M_AN_RF) {
1471                 DBG(PFX "%s: remote fault\n", sky2->netdev->name);
1472                 return -1;
1473         }
1474
1475         if (!(aux & PHY_M_PS_SPDUP_RES)) {
1476                 DBG(PFX "%s: speed/duplex mismatch\n", sky2->netdev->name);
1477                 return -1;
1478         }
1479
1480         sky2->speed = sky2_phy_speed(hw, aux);
1481         sky2->duplex = (aux & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
1482
1483         /* Since the pause result bits seem to in different positions on
1484          * different chips. look at registers.
1485          */
1486
1487         sky2->flow_status = FC_NONE;
1488         if (advert & ADVERTISE_PAUSE_CAP) {
1489                 if (lpa & LPA_PAUSE_CAP)
1490                         sky2->flow_status = FC_BOTH;
1491                 else if (advert & ADVERTISE_PAUSE_ASYM)
1492                         sky2->flow_status = FC_RX;
1493         } else if (advert & ADVERTISE_PAUSE_ASYM) {
1494                 if ((lpa & LPA_PAUSE_CAP) && (lpa & LPA_PAUSE_ASYM))
1495                         sky2->flow_status = FC_TX;
1496         }
1497
1498         if (sky2->duplex == DUPLEX_HALF && sky2->speed < SPEED_1000
1499             && !(hw->chip_id == CHIP_ID_YUKON_EC_U || hw->chip_id == CHIP_ID_YUKON_EX))
1500                 sky2->flow_status = FC_NONE;
1501
1502         if (sky2->flow_status & FC_TX)
1503                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON);
1504         else
1505                 sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
1506
1507         return 0;
1508 }
1509
1510 /* Interrupt from PHY */
1511 static void sky2_phy_intr(struct sky2_hw *hw, unsigned port)
1512 {
1513         struct net_device *dev = hw->dev[port];
1514         struct sky2_port *sky2 = netdev_priv(dev);
1515         u16 istatus, phystat;
1516
1517         istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT);
1518         phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT);
1519
1520         DBGIO(PFX "%s: phy interrupt status 0x%x 0x%x\n",
1521               sky2->netdev->name, istatus, phystat);
1522
1523         if (sky2->autoneg == AUTONEG_ENABLE && (istatus & PHY_M_IS_AN_COMPL)) {
1524                 if (sky2_autoneg_done(sky2, phystat) == 0)
1525                         sky2_link_up(sky2);
1526                 return;
1527         }
1528
1529         if (istatus & PHY_M_IS_LSP_CHANGE)
1530                 sky2->speed = sky2_phy_speed(hw, phystat);
1531
1532         if (istatus & PHY_M_IS_DUP_CHANGE)
1533                 sky2->duplex =
1534                     (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
1535
1536         if (istatus & PHY_M_IS_LST_CHANGE) {
1537                 if (phystat & PHY_M_PS_LINK_UP)
1538                         sky2_link_up(sky2);
1539                 else
1540                         sky2_link_down(sky2);
1541         }
1542 }
1543
1544 /* Normal packet - take iob from ring element and put in a new one  */
1545 static struct io_buffer *receive_new(struct sky2_port *sky2,
1546                                      struct rx_ring_info *re,
1547                                      unsigned int length)
1548 {
1549         struct io_buffer *iob, *niob;
1550         unsigned hdr_space = sky2->rx_data_size;
1551
1552         /* Don't be tricky about reusing pages (yet) */
1553         niob = sky2_rx_alloc(sky2);
1554         if (!niob)
1555                 return NULL;
1556
1557         iob = re->iob;
1558
1559         re->iob = niob;
1560         sky2_rx_map_iob(sky2->hw->pdev, re, hdr_space);
1561
1562         iob_put(iob, length);
1563         return iob;
1564 }
1565
1566 /*
1567  * Receive one packet.
1568  * For larger packets, get new buffer.
1569  */
1570 static struct io_buffer *sky2_receive(struct net_device *dev,
1571                                       u16 length, u32 status)
1572 {
1573         struct sky2_port *sky2 = netdev_priv(dev);
1574         struct rx_ring_info *re = sky2->rx_ring + sky2->rx_next;
1575         struct io_buffer *iob = NULL;
1576         u16 count = (status & GMR_FS_LEN) >> 16;
1577
1578         DBGIO(PFX "%s: rx slot %d status 0x%x len %d\n",
1579               dev->name, sky2->rx_next, status, length);
1580
1581         sky2->rx_next = (sky2->rx_next + 1) % RX_PENDING;
1582
1583         /* This chip has hardware problems that generates bogus status.
1584          * So do only marginal checking and expect higher level protocols
1585          * to handle crap frames.
1586          */
1587         if (sky2->hw->chip_id == CHIP_ID_YUKON_FE_P &&
1588             sky2->hw->chip_rev == CHIP_REV_YU_FE2_A0 &&
1589             length == count)
1590                 goto okay;
1591
1592         if (status & GMR_FS_ANY_ERR)
1593                 goto error;
1594
1595         if (!(status & GMR_FS_RX_OK))
1596                 goto resubmit;
1597
1598         /* if length reported by DMA does not match PHY, packet was truncated */
1599         if (length != count)
1600                 goto len_error;
1601
1602 okay:
1603         iob = receive_new(sky2, re, length);
1604 resubmit:
1605         sky2_rx_submit(sky2, re);
1606
1607         return iob;
1608
1609 len_error:
1610         /* Truncation of overlength packets
1611            causes PHY length to not match MAC length */
1612         DBG2(PFX "%s: rx length error: status %#x length %d\n",
1613              dev->name, status, length);
1614
1615         /* Pass NULL as iob because we want to keep our iob in the
1616            ring for the next packet. */
1617         netdev_rx_err(dev, NULL, -EINVAL);
1618         goto resubmit;
1619
1620 error:
1621         if (status & GMR_FS_RX_FF_OV) {
1622                 DBG2(PFX "%s: FIFO overflow error\n", dev->name);
1623                 netdev_rx_err(dev, NULL, -EBUSY);
1624                 goto resubmit;
1625         }
1626
1627         DBG2(PFX "%s: rx error, status 0x%x length %d\n",
1628              dev->name, status, length);
1629         netdev_rx_err(dev, NULL, -EIO);
1630
1631         goto resubmit;
1632 }
1633
1634 /* Transmit complete */
1635 static inline void sky2_tx_done(struct net_device *dev, u16 last)
1636 {
1637         struct sky2_port *sky2 = netdev_priv(dev);
1638
1639         sky2_tx_complete(sky2, last);
1640 }
1641
1642 /* Process status response ring */
1643 static void sky2_status_intr(struct sky2_hw *hw, u16 idx)
1644 {
1645         unsigned rx[2] = { 0, 0 };
1646
1647         rmb();
1648         do {
1649                 struct sky2_status_le *le  = hw->st_le + hw->st_idx;
1650                 unsigned port;
1651                 struct net_device *dev;
1652                 struct io_buffer *iob;
1653                 u32 status;
1654                 u16 length;
1655                 u8 opcode = le->opcode;
1656
1657                 if (!(opcode & HW_OWNER))
1658                         break;
1659
1660                 port = le->css & CSS_LINK_BIT;
1661                 dev = hw->dev[port];
1662                 length = le16_to_cpu(le->length);
1663                 status = le32_to_cpu(le->status);
1664
1665                 hw->st_idx = RING_NEXT(hw->st_idx, STATUS_RING_SIZE);
1666
1667                 le->opcode = 0;
1668                 switch (opcode & ~HW_OWNER) {
1669                 case OP_RXSTAT:
1670                         ++rx[port];
1671                         iob = sky2_receive(dev, length, status);
1672                         if (!iob) {
1673                                 netdev_rx_err(dev, NULL, -ENOMEM);
1674                                 break;
1675                         }
1676
1677                         netdev_rx(dev, iob);
1678                         break;
1679
1680                 case OP_RXCHKS:
1681                         DBG2(PFX "status OP_RXCHKS but checksum offloading disabled\n");
1682                         break;
1683
1684                 case OP_TXINDEXLE:
1685                         /* TX index reports status for both ports */
1686                         assert(TX_RING_SIZE <= 0x1000);
1687                         sky2_tx_done(hw->dev[0], status & 0xfff);
1688                         if (hw->dev[1])
1689                                 sky2_tx_done(hw->dev[1],
1690                                      ((status >> 24) & 0xff)
1691                                              | (u16)(length & 0xf) << 8);
1692                         break;
1693
1694                 default:
1695                         DBG(PFX "unknown status opcode 0x%x\n", opcode);
1696                 }
1697         } while (hw->st_idx != idx);
1698
1699         /* Fully processed status ring so clear irq */
1700         sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
1701
1702         if (rx[0])
1703                 sky2_rx_update(netdev_priv(hw->dev[0]), Q_R1);
1704
1705         if (rx[1])
1706                 sky2_rx_update(netdev_priv(hw->dev[1]), Q_R2);
1707 }
1708
1709 static void sky2_hw_error(struct sky2_hw *hw, unsigned port, u32 status)
1710 {
1711         struct net_device *dev = hw->dev[port];
1712
1713         DBGIO(PFX "%s: hw error interrupt status 0x%x\n", dev->name, status);
1714
1715         if (status & Y2_IS_PAR_RD1) {
1716                 DBG(PFX "%s: ram data read parity error\n", dev->name);
1717                 /* Clear IRQ */
1718                 sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_RD_PERR);
1719         }
1720
1721         if (status & Y2_IS_PAR_WR1) {
1722                 DBG(PFX "%s: ram data write parity error\n", dev->name);
1723                 sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_WR_PERR);
1724         }
1725
1726         if (status & Y2_IS_PAR_MAC1) {
1727                 DBG(PFX "%s: MAC parity error\n", dev->name);
1728                 sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_PE);
1729         }
1730
1731         if (status & Y2_IS_PAR_RX1) {
1732                 DBG(PFX "%s: RX parity error\n", dev->name);
1733                 sky2_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), BMU_CLR_IRQ_PAR);
1734         }
1735
1736         if (status & Y2_IS_TCP_TXA1) {
1737                 DBG(PFX "%s: TCP segmentation error\n", dev->name);
1738                 sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_CLR_IRQ_TCP);
1739         }
1740 }
1741
1742 static void sky2_hw_intr(struct sky2_hw *hw)
1743 {
1744         u32 status = sky2_read32(hw, B0_HWE_ISRC);
1745         u32 hwmsk = sky2_read32(hw, B0_HWE_IMSK);
1746
1747         status &= hwmsk;
1748
1749         if (status & Y2_IS_TIST_OV)
1750                 sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
1751
1752         if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) {
1753                 u16 pci_err;
1754
1755                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
1756                 pci_err = sky2_pci_read16(hw, PCI_STATUS);
1757                 DBG(PFX "PCI hardware error (0x%x)\n", pci_err);
1758
1759                 sky2_pci_write16(hw, PCI_STATUS,
1760                                  pci_err | PCI_STATUS_ERROR_BITS);
1761                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
1762         }
1763
1764         if (status & Y2_IS_PCI_EXP) {
1765                 /* PCI-Express uncorrectable Error occurred */
1766                 u32 err;
1767
1768                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
1769                 err = sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
1770                 sky2_write32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS,
1771                              0xfffffffful);
1772                 DBG(PFX "PCI-Express error (0x%x)\n", err);
1773
1774                 sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
1775                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
1776         }
1777
1778         if (status & Y2_HWE_L1_MASK)
1779                 sky2_hw_error(hw, 0, status);
1780         status >>= 8;
1781         if (status & Y2_HWE_L1_MASK)
1782                 sky2_hw_error(hw, 1, status);
1783 }
1784
1785 static void sky2_mac_intr(struct sky2_hw *hw, unsigned port)
1786 {
1787         struct net_device *dev = hw->dev[port];
1788         u8 status = sky2_read8(hw, SK_REG(port, GMAC_IRQ_SRC));
1789
1790         DBGIO(PFX "%s: mac interrupt status 0x%x\n", dev->name, status);
1791
1792         if (status & GM_IS_RX_CO_OV)
1793                 gma_read16(hw, port, GM_RX_IRQ_SRC);
1794
1795         if (status & GM_IS_TX_CO_OV)
1796                 gma_read16(hw, port, GM_TX_IRQ_SRC);
1797
1798         if (status & GM_IS_RX_FF_OR) {
1799                 sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_CLI_RX_FO);
1800         }
1801
1802         if (status & GM_IS_TX_FF_UR) {
1803                 sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_FU);
1804         }
1805 }
1806
1807 /* This should never happen it is a bug. */
1808 static void sky2_le_error(struct sky2_hw *hw, unsigned port,
1809                           u16 q, unsigned ring_size __unused)
1810 {
1811         struct net_device *dev = hw->dev[port];
1812         struct sky2_port *sky2 = netdev_priv(dev);
1813         int idx;
1814         const u64 *le = (q == Q_R1 || q == Q_R2)
1815                 ? (u64 *) sky2->rx_le : (u64 *) sky2->tx_le;
1816
1817         idx = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX));
1818         DBG(PFX "%s: descriptor error q=%#x get=%d [%llx] last=%d put=%d should be %d\n",
1819             dev->name, (unsigned) q, idx, (unsigned long long) le[idx],
1820             (int) sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_LAST_IDX)),
1821             (int) sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX)),
1822             le == (u64 *)sky2->rx_le? sky2->rx_put : sky2->tx_prod);
1823
1824         sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_IRQ_CHK);
1825 }
1826
1827 /* Hardware/software error handling */
1828 static void sky2_err_intr(struct sky2_hw *hw, u32 status)
1829 {
1830         DBG(PFX "error interrupt status=%#x\n", status);
1831
1832         if (status & Y2_IS_HW_ERR)
1833                 sky2_hw_intr(hw);
1834
1835         if (status & Y2_IS_IRQ_MAC1)
1836                 sky2_mac_intr(hw, 0);
1837
1838         if (status & Y2_IS_IRQ_MAC2)
1839                 sky2_mac_intr(hw, 1);
1840
1841         if (status & Y2_IS_CHK_RX1)
1842                 sky2_le_error(hw, 0, Q_R1, RX_LE_SIZE);
1843
1844         if (status & Y2_IS_CHK_RX2)
1845                 sky2_le_error(hw, 1, Q_R2, RX_LE_SIZE);
1846
1847         if (status & Y2_IS_CHK_TXA1)
1848                 sky2_le_error(hw, 0, Q_XA1, TX_RING_SIZE);
1849
1850         if (status & Y2_IS_CHK_TXA2)
1851                 sky2_le_error(hw, 1, Q_XA2, TX_RING_SIZE);
1852 }
1853
1854 static void sky2_poll(struct net_device *dev)
1855 {
1856         struct sky2_port *sky2 = netdev_priv(dev);
1857         struct sky2_hw *hw = sky2->hw;
1858         u32 status = sky2_read32(hw, B0_Y2_SP_EISR);
1859         u16 idx;
1860
1861         if (status & Y2_IS_ERROR)
1862                 sky2_err_intr(hw, status);
1863
1864         if (status & Y2_IS_IRQ_PHY1)
1865                 sky2_phy_intr(hw, 0);
1866
1867         if (status & Y2_IS_IRQ_PHY2)
1868                 sky2_phy_intr(hw, 1);
1869
1870         while ((idx = sky2_read16(hw, STAT_PUT_IDX)) != hw->st_idx) {
1871                 sky2_status_intr(hw, idx);
1872         }
1873
1874         /* Bug/Errata workaround?
1875          * Need to kick the TX irq moderation timer.
1876          */
1877         if (sky2_read8(hw, STAT_TX_TIMER_CTRL) == TIM_START) {
1878                 sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
1879                 sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
1880         }
1881         sky2_read32(hw, B0_Y2_SP_LISR);
1882 }
1883
1884 /* Chip internal frequency for clock calculations */
1885 static u32 sky2_mhz(const struct sky2_hw *hw)
1886 {
1887         switch (hw->chip_id) {
1888         case CHIP_ID_YUKON_EC:
1889         case CHIP_ID_YUKON_EC_U:
1890         case CHIP_ID_YUKON_EX:
1891         case CHIP_ID_YUKON_SUPR:
1892         case CHIP_ID_YUKON_UL_2:
1893                 return 125;
1894
1895         case CHIP_ID_YUKON_FE:
1896                 return 100;
1897
1898         case CHIP_ID_YUKON_FE_P:
1899                 return 50;
1900
1901         case CHIP_ID_YUKON_XL:
1902                 return 156;
1903
1904         default:
1905                 DBG(PFX "unknown chip ID!\n");
1906                 return 100;     /* bogus */
1907         }
1908 }
1909
1910 static inline u32 sky2_us2clk(const struct sky2_hw *hw, u32 us)
1911 {
1912         return sky2_mhz(hw) * us;
1913 }
1914
1915 static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk)
1916 {
1917         return clk / sky2_mhz(hw);
1918 }
1919
1920 static int sky2_init(struct sky2_hw *hw)
1921 {
1922         u8 t8;
1923
1924         /* Enable all clocks and check for bad PCI access */
1925         sky2_pci_write32(hw, PCI_DEV_REG3, 0);
1926
1927         sky2_write8(hw, B0_CTST, CS_RST_CLR);
1928
1929         hw->chip_id = sky2_read8(hw, B2_CHIP_ID);
1930         hw->chip_rev = (sky2_read8(hw, B2_MAC_CFG) & CFG_CHIP_R_MSK) >> 4;
1931
1932         switch(hw->chip_id) {
1933         case CHIP_ID_YUKON_XL:
1934                 hw->flags = SKY2_HW_GIGABIT | SKY2_HW_NEWER_PHY;
1935                 break;
1936
1937         case CHIP_ID_YUKON_EC_U:
1938                 hw->flags = SKY2_HW_GIGABIT
1939                         | SKY2_HW_NEWER_PHY
1940                         | SKY2_HW_ADV_POWER_CTL;
1941                 break;
1942
1943         case CHIP_ID_YUKON_EX:
1944                 hw->flags = SKY2_HW_GIGABIT
1945                         | SKY2_HW_NEWER_PHY
1946                         | SKY2_HW_NEW_LE
1947                         | SKY2_HW_ADV_POWER_CTL;
1948                 break;
1949
1950         case CHIP_ID_YUKON_EC:
1951                 /* This rev is really old, and requires untested workarounds */
1952                 if (hw->chip_rev == CHIP_REV_YU_EC_A1) {
1953                         DBG(PFX "unsupported revision Yukon-EC rev A1\n");
1954                         return -EOPNOTSUPP;
1955                 }
1956                 hw->flags = SKY2_HW_GIGABIT;
1957                 break;
1958
1959         case CHIP_ID_YUKON_FE:
1960                 break;
1961
1962         case CHIP_ID_YUKON_FE_P:
1963                 hw->flags = SKY2_HW_NEWER_PHY
1964                         | SKY2_HW_NEW_LE
1965                         | SKY2_HW_AUTO_TX_SUM
1966                         | SKY2_HW_ADV_POWER_CTL;
1967                 break;
1968
1969         case CHIP_ID_YUKON_SUPR:
1970                 hw->flags = SKY2_HW_GIGABIT
1971                         | SKY2_HW_NEWER_PHY
1972                         | SKY2_HW_NEW_LE
1973                         | SKY2_HW_AUTO_TX_SUM
1974                         | SKY2_HW_ADV_POWER_CTL;
1975                 break;
1976
1977         case CHIP_ID_YUKON_UL_2:
1978                 hw->flags = SKY2_HW_GIGABIT
1979                         | SKY2_HW_ADV_POWER_CTL;
1980                 break;
1981
1982         default:
1983                 DBG(PFX "unsupported chip type 0x%x\n", hw->chip_id);
1984                 return -EOPNOTSUPP;
1985         }
1986
1987         hw->pmd_type = sky2_read8(hw, B2_PMD_TYP);
1988         if (hw->pmd_type == 'L' || hw->pmd_type == 'S' || hw->pmd_type == 'P')
1989                 hw->flags |= SKY2_HW_FIBRE_PHY;
1990
1991         hw->ports = 1;
1992         t8 = sky2_read8(hw, B2_Y2_HW_RES);
1993         if ((t8 & CFG_DUAL_MAC_MSK) == CFG_DUAL_MAC_MSK) {
1994                 if (!(sky2_read8(hw, B2_Y2_CLK_GATE) & Y2_STATUS_LNK2_INAC))
1995                         ++hw->ports;
1996         }
1997
1998         return 0;
1999 }
2000
2001 static void sky2_reset(struct sky2_hw *hw)
2002 {
2003         u16 status;
2004         int i, cap;
2005         u32 hwe_mask = Y2_HWE_ALL_MASK;
2006
2007         /* disable ASF */
2008         if (hw->chip_id == CHIP_ID_YUKON_EX) {
2009                 status = sky2_read16(hw, HCU_CCSR);
2010                 status &= ~(HCU_CCSR_AHB_RST | HCU_CCSR_CPU_RST_MODE |
2011                             HCU_CCSR_UC_STATE_MSK);
2012                 sky2_write16(hw, HCU_CCSR, status);
2013         } else
2014                 sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
2015         sky2_write16(hw, B0_CTST, Y2_ASF_DISABLE);
2016
2017         /* do a SW reset */
2018         sky2_write8(hw, B0_CTST, CS_RST_SET);
2019         sky2_write8(hw, B0_CTST, CS_RST_CLR);
2020
2021         /* allow writes to PCI config */
2022         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2023
2024         /* clear PCI errors, if any */
2025         status = sky2_pci_read16(hw, PCI_STATUS);
2026         status |= PCI_STATUS_ERROR_BITS;
2027         sky2_pci_write16(hw, PCI_STATUS, status);
2028
2029         sky2_write8(hw, B0_CTST, CS_MRST_CLR);
2030
2031         cap = pci_find_capability(hw->pdev, PCI_CAP_ID_EXP);
2032         if (cap) {
2033                 sky2_write32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS,
2034                              0xfffffffful);
2035
2036                 /* If an error bit is stuck on ignore it */
2037                 if (sky2_read32(hw, B0_HWE_ISRC) & Y2_IS_PCI_EXP)
2038                         DBG(PFX "ignoring stuck error report bit\n");
2039                 else
2040                         hwe_mask |= Y2_IS_PCI_EXP;
2041         }
2042
2043         sky2_power_on(hw);
2044         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2045
2046         for (i = 0; i < hw->ports; i++) {
2047                 sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET);
2048                 sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_CLR);
2049
2050                 if (hw->chip_id == CHIP_ID_YUKON_EX ||
2051                     hw->chip_id == CHIP_ID_YUKON_SUPR)
2052                         sky2_write16(hw, SK_REG(i, GMAC_CTRL),
2053                                      GMC_BYP_MACSECRX_ON | GMC_BYP_MACSECTX_ON
2054                                      | GMC_BYP_RETR_ON);
2055         }
2056
2057         /* Clear I2C IRQ noise */
2058         sky2_write32(hw, B2_I2C_IRQ, 1);
2059
2060         /* turn off hardware timer (unused) */
2061         sky2_write8(hw, B2_TI_CTRL, TIM_STOP);
2062         sky2_write8(hw, B2_TI_CTRL, TIM_CLR_IRQ);
2063
2064         sky2_write8(hw, B0_Y2LED, LED_STAT_ON);
2065
2066         /* Turn off descriptor polling */
2067         sky2_write32(hw, B28_DPT_CTRL, DPT_STOP);
2068
2069         /* Turn off receive timestamp */
2070         sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_STOP);
2071         sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
2072
2073         /* enable the Tx Arbiters */
2074         for (i = 0; i < hw->ports; i++)
2075                 sky2_write8(hw, SK_REG(i, TXA_CTRL), TXA_ENA_ARB);
2076
2077         /* Initialize ram interface */
2078         for (i = 0; i < hw->ports; i++) {
2079                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_CTRL), RI_RST_CLR);
2080
2081                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R1), SK_RI_TO_53);
2082                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA1), SK_RI_TO_53);
2083                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS1), SK_RI_TO_53);
2084                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R1), SK_RI_TO_53);
2085                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA1), SK_RI_TO_53);
2086                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS1), SK_RI_TO_53);
2087                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R2), SK_RI_TO_53);
2088                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA2), SK_RI_TO_53);
2089                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS2), SK_RI_TO_53);
2090                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R2), SK_RI_TO_53);
2091                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA2), SK_RI_TO_53);
2092                 sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS2), SK_RI_TO_53);
2093         }
2094
2095         sky2_write32(hw, B0_HWE_IMSK, hwe_mask);
2096
2097         for (i = 0; i < hw->ports; i++)
2098                 sky2_gmac_reset(hw, i);
2099
2100         memset(hw->st_le, 0, STATUS_LE_BYTES);
2101         hw->st_idx = 0;
2102
2103         sky2_write32(hw, STAT_CTRL, SC_STAT_RST_SET);
2104         sky2_write32(hw, STAT_CTRL, SC_STAT_RST_CLR);
2105
2106         sky2_write32(hw, STAT_LIST_ADDR_LO, hw->st_dma);
2107         sky2_write32(hw, STAT_LIST_ADDR_HI, (u64) hw->st_dma >> 32);
2108
2109         /* Set the list last index */
2110         sky2_write16(hw, STAT_LAST_IDX, STATUS_RING_SIZE - 1);
2111
2112         sky2_write16(hw, STAT_TX_IDX_TH, 10);
2113         sky2_write8(hw, STAT_FIFO_WM, 16);
2114
2115         /* set Status-FIFO ISR watermark */
2116         if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0)
2117                 sky2_write8(hw, STAT_FIFO_ISR_WM, 4);
2118         else
2119                 sky2_write8(hw, STAT_FIFO_ISR_WM, 16);
2120
2121         sky2_write32(hw, STAT_TX_TIMER_INI, sky2_us2clk(hw, 1000));
2122         sky2_write32(hw, STAT_ISR_TIMER_INI, sky2_us2clk(hw, 20));
2123         sky2_write32(hw, STAT_LEV_TIMER_INI, sky2_us2clk(hw, 100));
2124
2125         /* enable status unit */
2126         sky2_write32(hw, STAT_CTRL, SC_STAT_OP_ON);
2127
2128         sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
2129         sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START);
2130         sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
2131 }
2132
2133 static u32 sky2_supported_modes(const struct sky2_hw *hw)
2134 {
2135         if (sky2_is_copper(hw)) {
2136                 u32 modes = SUPPORTED_10baseT_Half
2137                         | SUPPORTED_10baseT_Full
2138                         | SUPPORTED_100baseT_Half
2139                         | SUPPORTED_100baseT_Full
2140                         | SUPPORTED_Autoneg | SUPPORTED_TP;
2141
2142                 if (hw->flags & SKY2_HW_GIGABIT)
2143                         modes |= SUPPORTED_1000baseT_Half
2144                                 | SUPPORTED_1000baseT_Full;
2145                 return modes;
2146         } else
2147                 return  SUPPORTED_1000baseT_Half
2148                         | SUPPORTED_1000baseT_Full
2149                         | SUPPORTED_Autoneg
2150                         | SUPPORTED_FIBRE;
2151 }
2152
2153 static void sky2_set_multicast(struct net_device *dev)
2154 {
2155         struct sky2_port *sky2 = netdev_priv(dev);
2156         struct sky2_hw *hw = sky2->hw;
2157         unsigned port = sky2->port;
2158         u16 reg;
2159         u8 filter[8];
2160
2161         reg = gma_read16(hw, port, GM_RX_CTRL);
2162         reg |= GM_RXCR_UCF_ENA;
2163
2164         memset(filter, 0xff, sizeof(filter));
2165
2166         gma_write16(hw, port, GM_MC_ADDR_H1,
2167                     (u16) filter[0] | ((u16) filter[1] << 8));
2168         gma_write16(hw, port, GM_MC_ADDR_H2,
2169                     (u16) filter[2] | ((u16) filter[3] << 8));
2170         gma_write16(hw, port, GM_MC_ADDR_H3,
2171                     (u16) filter[4] | ((u16) filter[5] << 8));
2172         gma_write16(hw, port, GM_MC_ADDR_H4,
2173                     (u16) filter[6] | ((u16) filter[7] << 8));
2174
2175         gma_write16(hw, port, GM_RX_CTRL, reg);
2176 }
2177
2178 /* Initialize network device */
2179 static struct net_device *sky2_init_netdev(struct sky2_hw *hw,
2180                                                      unsigned port)
2181 {
2182         struct sky2_port *sky2;
2183         struct net_device *dev = alloc_etherdev(sizeof(*sky2));
2184
2185         if (!dev) {
2186                 DBG(PFX "etherdev alloc failed\n");
2187                 return NULL;
2188         }
2189
2190         dev->dev = &hw->pdev->dev;
2191
2192         sky2 = netdev_priv(dev);
2193         sky2->netdev = dev;
2194         sky2->hw = hw;
2195
2196         /* Auto speed and flow control */
2197         sky2->autoneg = AUTONEG_ENABLE;
2198         sky2->flow_mode = FC_BOTH;
2199
2200         sky2->duplex = -1;
2201         sky2->speed = -1;
2202         sky2->advertising = sky2_supported_modes(hw);
2203
2204         hw->dev[port] = dev;
2205
2206         sky2->port = port;
2207
2208         /* read the mac address */
2209         memcpy(dev->hw_addr, (void *)(hw->regs + B2_MAC_1 + port * 8), ETH_ALEN);
2210
2211         return dev;
2212 }
2213
2214 static void sky2_show_addr(struct net_device *dev)
2215 {
2216         DBG2(PFX "%s: addr %s\n", dev->name, netdev_addr(dev));
2217 }
2218
2219 #if DBGLVL_MAX
2220 /* This driver supports yukon2 chipset only */
2221 static const char *sky2_name(u8 chipid, char *buf, int sz)
2222 {
2223         const char *name[] = {
2224                 "XL",           /* 0xb3 */
2225                 "EC Ultra",     /* 0xb4 */
2226                 "Extreme",      /* 0xb5 */
2227                 "EC",           /* 0xb6 */
2228                 "FE",           /* 0xb7 */
2229                 "FE+",          /* 0xb8 */
2230                 "Supreme",      /* 0xb9 */
2231                 "UL 2",         /* 0xba */
2232         };
2233
2234         if (chipid >= CHIP_ID_YUKON_XL && chipid <= CHIP_ID_YUKON_UL_2)
2235                 strncpy(buf, name[chipid - CHIP_ID_YUKON_XL], sz);
2236         else
2237                 snprintf(buf, sz, "(chip %#x)", chipid);
2238         return buf;
2239 }
2240 #endif
2241
2242 static void sky2_net_irq(struct net_device *dev, int enable)
2243 {
2244         struct sky2_port *sky2 = netdev_priv(dev);
2245         struct sky2_hw *hw = sky2->hw;
2246
2247         u32 imask = sky2_read32(hw, B0_IMSK);
2248         if (enable)
2249                 imask |= portirq_msk[sky2->port];
2250         else
2251                 imask &= ~portirq_msk[sky2->port];
2252         sky2_write32(hw, B0_IMSK, imask);
2253 }
2254
2255 static struct net_device_operations sky2_operations = {
2256         .open     = sky2_up,
2257         .close    = sky2_down,
2258         .transmit = sky2_xmit_frame,
2259         .poll     = sky2_poll,
2260         .irq      = sky2_net_irq
2261 };
2262
2263 static int sky2_probe(struct pci_device *pdev)
2264 {
2265         struct net_device *dev;
2266         struct sky2_hw *hw;
2267         int err;
2268         char buf1[16] __unused; /* only for debugging */
2269
2270         adjust_pci_device(pdev);
2271
2272         err = -ENOMEM;
2273         hw = zalloc(sizeof(*hw));
2274         if (!hw) {
2275                 DBG(PFX "cannot allocate hardware struct\n");
2276                 goto err_out;
2277         }
2278
2279         hw->pdev = pdev;
2280
2281         hw->regs = (unsigned long)ioremap(pci_bar_start(pdev, PCI_BASE_ADDRESS_0), 0x4000);
2282         if (!hw->regs) {
2283                 DBG(PFX "cannot map device registers\n");
2284                 goto err_out_free_hw;
2285         }
2286
2287         /* ring for status responses */
2288         hw->st_le = malloc_dma(STATUS_LE_BYTES, STATUS_RING_ALIGN);
2289         if (!hw->st_le)
2290                 goto err_out_iounmap;
2291         hw->st_dma = virt_to_bus(hw->st_le);
2292         memset(hw->st_le, 0, STATUS_LE_BYTES);
2293
2294         err = sky2_init(hw);
2295         if (err)
2296                 goto err_out_iounmap;
2297
2298 #if DBGLVL_MAX
2299         DBG2(PFX "Yukon-2 %s chip revision %d\n",
2300              sky2_name(hw->chip_id, buf1, sizeof(buf1)), hw->chip_rev);
2301 #endif
2302
2303         sky2_reset(hw);
2304
2305         dev = sky2_init_netdev(hw, 0);
2306         if (!dev) {
2307                 err = -ENOMEM;
2308                 goto err_out_free_pci;
2309         }
2310
2311         netdev_init(dev, &sky2_operations);
2312
2313         err = register_netdev(dev);
2314         if (err) {
2315                 DBG(PFX "cannot register net device\n");
2316                 goto err_out_free_netdev;
2317         }
2318
2319         sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
2320
2321         sky2_show_addr(dev);
2322
2323         if (hw->ports > 1) {
2324                 struct net_device *dev1;
2325
2326                 dev1 = sky2_init_netdev(hw, 1);
2327                 if (!dev1)
2328                         DBG(PFX "allocation for second device failed\n");
2329                 else if ((err = register_netdev(dev1))) {
2330                         DBG(PFX "register of second port failed (%d)\n", err);
2331                         hw->dev[1] = NULL;
2332                         netdev_nullify(dev1);
2333                         netdev_put(dev1);
2334                 } else
2335                         sky2_show_addr(dev1);
2336         }
2337
2338         pci_set_drvdata(pdev, hw);
2339
2340         return 0;
2341
2342 err_out_free_netdev:
2343         netdev_nullify(dev);
2344         netdev_put(dev);
2345 err_out_free_pci:
2346         sky2_write8(hw, B0_CTST, CS_RST_SET);
2347         free_dma(hw->st_le, STATUS_LE_BYTES);
2348 err_out_iounmap:
2349         iounmap((void *)hw->regs);
2350 err_out_free_hw:
2351         free(hw);
2352 err_out:
2353         pci_set_drvdata(pdev, NULL);
2354         return err;
2355 }
2356
2357 static void sky2_remove(struct pci_device *pdev)
2358 {
2359         struct sky2_hw *hw = pci_get_drvdata(pdev);
2360         int i;
2361
2362         if (!hw)
2363                 return;
2364
2365         for (i = hw->ports-1; i >= 0; --i)
2366                 unregister_netdev(hw->dev[i]);
2367
2368         sky2_write32(hw, B0_IMSK, 0);
2369
2370         sky2_power_aux(hw);
2371
2372         sky2_write16(hw, B0_Y2LED, LED_STAT_OFF);
2373         sky2_write8(hw, B0_CTST, CS_RST_SET);
2374         sky2_read8(hw, B0_CTST);
2375
2376         free_dma(hw->st_le, STATUS_LE_BYTES);
2377
2378         for (i = hw->ports-1; i >= 0; --i) {
2379                 netdev_nullify(hw->dev[i]);
2380                 netdev_put(hw->dev[i]);
2381         }
2382
2383         iounmap((void *)hw->regs);
2384         free(hw);
2385
2386         pci_set_drvdata(pdev, NULL);
2387 }
2388
2389 struct pci_driver sky2_driver __pci_driver = {
2390         .ids      = sky2_id_table,
2391         .id_count = (sizeof (sky2_id_table) / sizeof (sky2_id_table[0])),
2392         .probe    = sky2_probe,
2393         .remove   = sky2_remove
2394 };