[PATCH] skge: fiber support

Add support for older fiber versions of the SysKonnect board. These chipsets
use an internal PHY so they require special handling. The older sk98lin
driver already supported these

Signed-off-by: Stephen Hemminger <shemminger@osdl.org>
Signed-off-by: Jeff Garzik <jeff@garzik.org>

1 files changed, 271 insertions, 86 deletions

diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 9142d91355bc..705e9a8fa30f 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -58,6 +58,7 @@
 #define TX_WATCHDOG             (5 * HZ)
 #define NAPI_WEIGHT             64
 #define BLINK_MS                250
+#define LINK_HZ                 (HZ/2)
 
 MODULE_DESCRIPTION("SysKonnect Gigabit Ethernet driver");
 MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
@@ -605,7 +606,12 @@ static void skge_led(struct skge_port *skge, enum led_mode mode)
         if (hw->chip_id == CHIP_ID_GENESIS) {
                 switch (mode) {
                 case LED_MODE_OFF:
-                        xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_OFF);
+                        if (hw->phy_type == SK_PHY_BCOM)
+                                xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_OFF);
+                        else {
+                                skge_write32(hw, SK_REG(port, TX_LED_VAL), 0);
+                                skge_write8(hw, SK_REG(port, TX_LED_CTRL), LED_T_OFF);
+                        }
                         skge_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF);
                         skge_write32(hw, SK_REG(port, RX_LED_VAL), 0);
                         skge_write8(hw, SK_REG(port, RX_LED_CTRL), LED_T_OFF);
@@ -625,8 +631,14 @@ static void skge_led(struct skge_port *skge, enum led_mode mode)
                         skge_write32(hw, SK_REG(port, RX_LED_VAL), 100);
                         skge_write8(hw, SK_REG(port, RX_LED_CTRL), LED_START);
 
-                        xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_ON);
-                        break;
+                        if (hw->phy_type == SK_PHY_BCOM)
+                                xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_ON);
+                        else {
+                                skge_write8(hw, SK_REG(port, TX_LED_TST), LED_T_ON);
+                                skge_write32(hw, SK_REG(port, TX_LED_VAL), 100);
+                                skge_write8(hw, SK_REG(port, TX_LED_CTRL), LED_START);
+                        }
+
                 }
         } else {
                 switch (mode) {
@@ -879,6 +891,9 @@ static int __xm_phy_read(struct skge_hw *hw, int port, u16 reg, u16 *val)
         xm_write16(hw, port, XM_PHY_ADDR, reg | hw->phy_addr);
         *val = xm_read16(hw, port, XM_PHY_DATA);
 
+        if (hw->phy_type == SK_PHY_XMAC)
+                goto ready;
+
         for (i = 0; i < PHY_RETRIES; i++) {
                 if (xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_RDY)
                         goto ready;
@@ -965,7 +980,8 @@ static void genesis_reset(struct skge_hw *hw, int port)
         xm_write16(hw, port, XM_RX_CMD, 0);     /* reset RX CMD Reg */
 
         /* disable Broadcom PHY IRQ */
-        xm_write16(hw, port, PHY_BCOM_INT_MASK, 0xffff);
+        if (hw->phy_type == SK_PHY_BCOM)
+                xm_write16(hw, port, PHY_BCOM_INT_MASK, 0xffff);
 
         xm_outhash(hw, port, XM_HSM, zero);
 }
@@ -1000,60 +1016,64 @@ static void bcom_check_link(struct skge_hw *hw, int port)
 
                 if (netif_carrier_ok(dev))
                         skge_link_down(skge);
-        } else {
-                if (skge->autoneg == AUTONEG_ENABLE &&
-                    (status & PHY_ST_AN_OVER)) {
-                        u16 lpa = xm_phy_read(hw, port, PHY_BCOM_AUNE_LP);
-                        u16 aux = xm_phy_read(hw, port, PHY_BCOM_AUX_STAT);
-
-                        if (lpa & PHY_B_AN_RF) {
-                                printk(KERN_NOTICE PFX "%s: remote fault\n",
-                                       dev->name);
-                                return;
-                        }
+                return;
+        }
 
-                        /* Check Duplex mismatch */
-                        switch (aux & PHY_B_AS_AN_RES_MSK) {
-                        case PHY_B_RES_1000FD:
-                                skge->duplex = DUPLEX_FULL;
-                                break;
-                        case PHY_B_RES_1000HD:
-                                skge->duplex = DUPLEX_HALF;
-                                break;
-                        default:
-                                printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
-                                       dev->name);
-                                return;
-                        }
+        if (skge->autoneg == AUTONEG_ENABLE) {
+                u16 lpa, aux;
 
+                if (!(status & PHY_ST_AN_OVER))
+                        return;
 
-                        /* We are using IEEE 802.3z/D5.0 Table 37-4 */
-                        switch (aux & PHY_B_AS_PAUSE_MSK) {
-                        case PHY_B_AS_PAUSE_MSK:
-                                skge->flow_control = FLOW_MODE_SYMMETRIC;
-                                break;
-                        case PHY_B_AS_PRR:
-                                skge->flow_control = FLOW_MODE_REM_SEND;
-                                break;
-                        case PHY_B_AS_PRT:
-                                skge->flow_control = FLOW_MODE_LOC_SEND;
-                                break;
-                        default:
-                                skge->flow_control = FLOW_MODE_NONE;
-                        }
+                lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
+                if (lpa & PHY_B_AN_RF) {
+                        printk(KERN_NOTICE PFX "%s: remote fault\n",
+                               dev->name);
+                        return;
+                }
 
-                        skge->speed = SPEED_1000;
+                aux = xm_phy_read(hw, port, PHY_BCOM_AUX_STAT);
+
+                /* Check Duplex mismatch */
+                switch (aux & PHY_B_AS_AN_RES_MSK) {
+                case PHY_B_RES_1000FD:
+                        skge->duplex = DUPLEX_FULL;
+                        break;
+                case PHY_B_RES_1000HD:
+                        skge->duplex = DUPLEX_HALF;
+                        break;
+                default:
+                        printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
+                               dev->name);
+                        return;
                 }
 
-                if (!netif_carrier_ok(dev))
-                        genesis_link_up(skge);
+
+                /* We are using IEEE 802.3z/D5.0 Table 37-4 */
+                switch (aux & PHY_B_AS_PAUSE_MSK) {
+                case PHY_B_AS_PAUSE_MSK:
+                        skge->flow_control = FLOW_MODE_SYMMETRIC;
+                        break;
+                case PHY_B_AS_PRR:
+                        skge->flow_control = FLOW_MODE_REM_SEND;
+                        break;
+                case PHY_B_AS_PRT:
+                        skge->flow_control = FLOW_MODE_LOC_SEND;
+                        break;
+                default:
+                        skge->flow_control = FLOW_MODE_NONE;
+                }
+                skge->speed = SPEED_1000;
         }
+
+        if (!netif_carrier_ok(dev))
+                genesis_link_up(skge);
 }
 
 /* Broadcom 5400 only supports giagabit! SysKonnect did not put an additional
  * Phy on for 100 or 10Mbit operation
  */
-static void bcom_phy_init(struct skge_port *skge, int jumbo)
+static void bcom_phy_init(struct skge_port *skge)
 {
         struct skge_hw *hw = skge->hw;
         int port = skge->port;
@@ -1144,7 +1164,7 @@ static void bcom_phy_init(struct skge_port *skge, int jumbo)
                      phy_pause_map[skge->flow_control] | PHY_AN_CSMA);
 
         /* Handle Jumbo frames */
-        if (jumbo) {
+        if (hw->dev[port]->mtu > ETH_DATA_LEN) {
                 xm_phy_write(hw, port, PHY_BCOM_AUX_CTRL,
                              PHY_B_AC_TX_TST | PHY_B_AC_LONG_PACK);
 
@@ -1157,8 +1177,154 @@ static void bcom_phy_init(struct skge_port *skge, int jumbo)
 
         /* Use link status change interrupt */
         xm_phy_write(hw, port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
+}
 
-        bcom_check_link(hw, port);
+static void xm_phy_init(struct skge_port *skge)
+{
+        struct skge_hw *hw = skge->hw;
+        int port = skge->port;
+        u16 ctrl = 0;
+
+        if (skge->autoneg == AUTONEG_ENABLE) {
+                if (skge->advertising & ADVERTISED_1000baseT_Half)
+                        ctrl |= PHY_X_AN_HD;
+                if (skge->advertising & ADVERTISED_1000baseT_Full)
+                        ctrl |= PHY_X_AN_FD;
+
+                switch(skge->flow_control) {
+                case FLOW_MODE_NONE:
+                        ctrl |= PHY_X_P_NO_PAUSE;
+                        break;
+                case FLOW_MODE_LOC_SEND:
+                        ctrl |= PHY_X_P_ASYM_MD;
+                        break;
+                case FLOW_MODE_SYMMETRIC:
+                        ctrl |= PHY_X_P_BOTH_MD;
+                        break;
+                }
+
+                xm_phy_write(hw, port, PHY_XMAC_AUNE_ADV, ctrl);
+
+                /* Restart Auto-negotiation */
+                ctrl = PHY_CT_ANE | PHY_CT_RE_CFG;
+        } else {
+                /* Set DuplexMode in Config register */
+                if (skge->duplex == DUPLEX_FULL)
+                        ctrl |= PHY_CT_DUP_MD;
+                /*
+                 * Do NOT enable Auto-negotiation here. This would hold
+                 * the link down because no IDLEs are transmitted
+                 */
+        }
+
+        xm_phy_write(hw, port, PHY_XMAC_CTRL, ctrl);
+
+        /* Poll PHY for status changes */
+        schedule_delayed_work(&skge->link_thread, LINK_HZ);
+}
+
+static void xm_check_link(struct net_device *dev)
+{
+        struct skge_port *skge = netdev_priv(dev);
+        struct skge_hw *hw = skge->hw;
+        int port = skge->port;
+        u16 status;
+
+        /* read twice because of latch */
+        (void) xm_phy_read(hw, port, PHY_XMAC_STAT);
+        status = xm_phy_read(hw, port, PHY_XMAC_STAT);
+
+        if ((status & PHY_ST_LSYNC) == 0) {
+                u16 cmd = xm_read16(hw, port, XM_MMU_CMD);
+                cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
+                xm_write16(hw, port, XM_MMU_CMD, cmd);
+                /* dummy read to ensure writing */
+                (void) xm_read16(hw, port, XM_MMU_CMD);
+
+                if (netif_carrier_ok(dev))
+                        skge_link_down(skge);
+                return;
+        }
+
+        if (skge->autoneg == AUTONEG_ENABLE) {
+                u16 lpa, res;
+
+                if (!(status & PHY_ST_AN_OVER))
+                        return;
+
+                lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
+                if (lpa & PHY_B_AN_RF) {
+                        printk(KERN_NOTICE PFX "%s: remote fault\n",
+                               dev->name);
+                        return;
+                }
+
+                res = xm_phy_read(hw, port, PHY_XMAC_RES_ABI);
+
+                /* Check Duplex mismatch */
+                switch (res & (PHY_X_RS_HD | PHY_X_RS_FD)) {
+                case PHY_X_RS_FD:
+                        skge->duplex = DUPLEX_FULL;
+                        break;
+                case PHY_X_RS_HD:
+                        skge->duplex = DUPLEX_HALF;
+                        break;
+                default:
+                        printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
+                               dev->name);
+                        return;
+                }
+
+                /* We are using IEEE 802.3z/D5.0 Table 37-4 */
+                if (lpa & PHY_X_P_SYM_MD)
+                        skge->flow_control = FLOW_MODE_SYMMETRIC;
+                else if ((lpa & PHY_X_RS_PAUSE) == PHY_X_P_ASYM_MD)
+                        skge->flow_control = FLOW_MODE_REM_SEND;
+                else if ((lpa & PHY_X_RS_PAUSE) == PHY_X_P_BOTH_MD)
+                        skge->flow_control = FLOW_MODE_LOC_SEND;
+                else
+                        skge->flow_control = FLOW_MODE_NONE;
+
+
+                skge->speed = SPEED_1000;
+        }
+
+        if (!netif_carrier_ok(dev))
+                genesis_link_up(skge);
+}
+
+/* Poll to check for link coming up.
+ * Since internal PHY is wired to a level triggered pin, can't
+ * get an interrupt when carrier is detected.
+ */
+static void xm_link_timer(void *arg)
+{
+        struct net_device *dev = arg;
+        struct skge_port *skge = netdev_priv(arg);
+        struct skge_hw *hw = skge->hw;
+        int port = skge->port;
+
+        if (!netif_running(dev))
+                return;
+
+        if (netif_carrier_ok(dev)) {
+                xm_read16(hw, port, XM_ISRC);
+                if (!(xm_read16(hw, port, XM_ISRC) & XM_IS_INP_ASS))
+                        goto nochange;
+        } else {
+                if (xm_read32(hw, port, XM_GP_PORT) & XM_GP_INP_ASS)
+                        goto nochange;
+                xm_read16(hw, port, XM_ISRC);
+                if (xm_read16(hw, port, XM_ISRC) & XM_IS_INP_ASS)
+                        goto nochange;
+        }
+
+        mutex_lock(&hw->phy_mutex);
+        xm_check_link(dev);
+        mutex_unlock(&hw->phy_mutex);
+
+nochange:
+        schedule_delayed_work(&skge->link_thread, LINK_HZ);
 }
 
 static void genesis_mac_init(struct skge_hw *hw, int port)
@@ -1189,20 +1355,29 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
          * namely for the 1000baseTX cards that use the XMAC's
          * GMII mode.
          */
-        /* Take external Phy out of reset */
-        r = skge_read32(hw, B2_GP_IO);
-        if (port == 0)
-                r |= GP_DIR_0|GP_IO_0;
-        else
-                r |= GP_DIR_2|GP_IO_2;
+        if (hw->phy_type != SK_PHY_XMAC) {
+                /* Take external Phy out of reset */
+                r = skge_read32(hw, B2_GP_IO);
+                if (port == 0)
+                        r |= GP_DIR_0|GP_IO_0;
+                else
+                        r |= GP_DIR_2|GP_IO_2;
 
-        skge_write32(hw, B2_GP_IO, r);
+                skge_write32(hw, B2_GP_IO, r);
 
+                /* Enable GMII interface */
+                xm_write16(hw, port, XM_HW_CFG, XM_HW_GMII_MD);
+        }
 
-        /* Enable GMII interface */
-        xm_write16(hw, port, XM_HW_CFG, XM_HW_GMII_MD);
 
-        bcom_phy_init(skge, jumbo);
+        switch(hw->phy_type) {
+        case SK_PHY_XMAC:
+                xm_phy_init(skge);
+                break;
+        case SK_PHY_BCOM:
+                bcom_phy_init(skge);
+                bcom_check_link(hw, port);
+        }
 
         /* Set Station Address */
         xm_outaddr(hw, port, XM_SA, dev->dev_addr);
@@ -1335,16 +1510,18 @@ static void genesis_stop(struct skge_port *skge)
         skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_SET_MAC_RST);
 
         /* For external PHYs there must be special handling */
-        reg = skge_read32(hw, B2_GP_IO);
-        if (port == 0) {
-                reg |= GP_DIR_0;
-                reg &= ~GP_IO_0;
-        } else {
-                reg |= GP_DIR_2;
-                reg &= ~GP_IO_2;
+        if (hw->phy_type != SK_PHY_XMAC) {
+                reg = skge_read32(hw, B2_GP_IO);
+                if (port == 0) {
+                        reg |= GP_DIR_0;
+                        reg &= ~GP_IO_0;
+                } else {
+                        reg |= GP_DIR_2;
+                        reg &= ~GP_IO_2;
+                }
+                skge_write32(hw, B2_GP_IO, reg);
+                skge_read32(hw, B2_GP_IO);
         }
-        skge_write32(hw, B2_GP_IO, reg);
-        skge_read32(hw, B2_GP_IO);
 
         xm_write16(hw, port, XM_MMU_CMD,
                         xm_read16(hw, port, XM_MMU_CMD)
@@ -1406,7 +1583,7 @@ static void genesis_link_up(struct skge_port *skge)
         struct skge_hw *hw = skge->hw;
         int port = skge->port;
         u16 cmd;
-        u32 mode, msk;
+        u32 mode;
 
         cmd = xm_read16(hw, port, XM_MMU_CMD);
 
@@ -1454,27 +1631,24 @@ static void genesis_link_up(struct skge_port *skge)
         }
 
         xm_write32(hw, port, XM_MODE, mode);
-
-        msk = XM_DEF_MSK;
-        /* disable GP0 interrupt bit for external Phy */
-        msk |= XM_IS_INP_ASS;
-
-        xm_write16(hw, port, XM_IMSK, msk);
+        xm_write16(hw, port, XM_IMSK, XM_DEF_MSK);
         xm_read16(hw, port, XM_ISRC);
 
         /* get MMU Command Reg. */
         cmd = xm_read16(hw, port, XM_MMU_CMD);
-        if (skge->duplex == DUPLEX_FULL)
+        if (hw->phy_type != SK_PHY_XMAC && skge->duplex == DUPLEX_FULL)
                 cmd |= XM_MMU_GMII_FD;
 
         /*
          * Workaround BCOM Errata (#10523) for all BCom Phys
          * Enable Power Management after link up
          */
-        xm_phy_write(hw, port, PHY_BCOM_AUX_CTRL,
-                     xm_phy_read(hw, port, PHY_BCOM_AUX_CTRL)
-                     & ~PHY_B_AC_DIS_PM);
-        xm_phy_write(hw, port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
+        if (hw->phy_type == SK_PHY_BCOM) {
+                xm_phy_write(hw, port, PHY_BCOM_AUX_CTRL,
+                             xm_phy_read(hw, port, PHY_BCOM_AUX_CTRL)
+                             & ~PHY_B_AC_DIS_PM);
+                xm_phy_write(hw, port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
+        }
 
         /* enable Rx/Tx */
         xm_write16(hw, port, XM_MMU_CMD,
@@ -2240,6 +2414,8 @@ static int skge_down(struct net_device *dev)
                 printk(KERN_INFO PFX "%s: disabling interface\n", dev->name);
 
         netif_stop_queue(dev);
+        if (hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC)
+                cancel_rearming_delayed_work(&skge->link_thread);
 
         skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_OFF);
         if (hw->chip_id == CHIP_ID_GENESIS)
@@ -2862,7 +3038,7 @@ static void skge_extirq(void *arg)
                 if (netif_running(dev)) {
                         if (hw->chip_id != CHIP_ID_GENESIS)
                                 yukon_phy_intr(skge);
-                        else
+                        else if (hw->phy_type == SK_PHY_BCOM)
                                 bcom_phy_intr(skge);
                 }
         }
@@ -3014,7 +3190,7 @@ static int skge_reset(struct skge_hw *hw)
 {
         u32 reg;
         u16 ctst, pci_status;
-        u8 t8, mac_cfg, pmd_type, phy_type;
+        u8 t8, mac_cfg, pmd_type;
         int i;
 
         ctst = skge_read16(hw, B0_CTST);
@@ -3038,19 +3214,22 @@ static int skge_reset(struct skge_hw *hw)
                      ctst & (CS_CLK_RUN_HOT|CS_CLK_RUN_RST|CS_CLK_RUN_ENA));
 
         hw->chip_id = skge_read8(hw, B2_CHIP_ID);
-        phy_type = skge_read8(hw, B2_E_1) & 0xf;
+        hw->phy_type = skge_read8(hw, B2_E_1) & 0xf;
         pmd_type = skge_read8(hw, B2_PMD_TYP);
         hw->copper = (pmd_type == 'T' || pmd_type == '1');
 
         switch (hw->chip_id) {
         case CHIP_ID_GENESIS:
-                switch (phy_type) {
+                switch (hw->phy_type) {
+                case SK_PHY_XMAC:
+                        hw->phy_addr = PHY_ADDR_XMAC;
+                        break;
                 case SK_PHY_BCOM:
                         hw->phy_addr = PHY_ADDR_BCOM;
                         break;
                 default:
                         printk(KERN_ERR PFX "%s: unsupported phy type 0x%x\n",
-                               pci_name(hw->pdev), phy_type);
+                               pci_name(hw->pdev), hw->phy_type);
                         return -EOPNOTSUPP;
                 }
                 break;
@@ -3058,7 +3237,7 @@ static int skge_reset(struct skge_hw *hw)
         case CHIP_ID_YUKON:
         case CHIP_ID_YUKON_LITE:
         case CHIP_ID_YUKON_LP:
-                if (phy_type < SK_PHY_MARV_COPPER && pmd_type != 'S')
+                if (hw->phy_type < SK_PHY_MARV_COPPER && pmd_type != 'S')
                         hw->copper = 1;
 
                 hw->phy_addr = PHY_ADDR_MARV;
@@ -3089,10 +3268,13 @@ static int skge_reset(struct skge_hw *hw)
         else
                 hw->ram_size = t8 * 4096;
 
-        hw->intr_mask = IS_HW_ERR | IS_EXT_REG | IS_PORT_1;
+        hw->intr_mask = IS_HW_ERR | IS_PORT_1;
         if (hw->ports > 1)
                 hw->intr_mask |= IS_PORT_2;
 
+        if (!(hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC))
+                hw->intr_mask |= IS_EXT_REG;
+
         if (hw->chip_id == CHIP_ID_GENESIS)
                 genesis_init(hw);
         else {
@@ -3226,6 +3408,9 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
 
         skge->port = port;
 
+        /* Only used for Genesis XMAC */
+        INIT_WORK(&skge->link_thread, xm_link_timer, dev);
+
         if (hw->chip_id != CHIP_ID_GENESIS) {
                 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
                 skge->rx_csum = 1;