generic: ar8216: move register inititalization into hw_init
[openwrt.git] / target / linux / generic / files / drivers / net / phy / ar8216.c
index 2e3a842..34322dd 100644 (file)
@@ -137,9 +137,11 @@ ar8216_id_chip(struct ar8216_priv *priv)
        u16 id;
        int i;
 
+       priv->chip = UNKNOWN;
+
        val = ar8216_mii_read(priv, AR8216_REG_CTRL);
        if (val == ~0)
-               return UNKNOWN;
+               return -ENODEV;
 
        id = val & (AR8216_CTRL_REVISION | AR8216_CTRL_VERSION);
        for (i = 0; i < AR8X16_PROBE_RETRIES; i++) {
@@ -147,21 +149,24 @@ ar8216_id_chip(struct ar8216_priv *priv)
 
                val = ar8216_mii_read(priv, AR8216_REG_CTRL);
                if (val == ~0)
-                       return UNKNOWN;
+                       return -ENODEV;
 
                t = val & (AR8216_CTRL_REVISION | AR8216_CTRL_VERSION);
                if (t != id)
-                       return UNKNOWN;
+                       return -ENODEV;
        }
 
        switch (id) {
        case 0x0101:
-               return AR8216;
+               priv->chip = AR8216;
+               break;
        case 0x0301:
-               return AR8236;
+               priv->chip = AR8236;
+               break;
        case 0x1000:
        case 0x1001:
-               return AR8316;
+               priv->chip = AR8316;
+               break;
        default:
                printk(KERN_DEBUG
                        "ar8216: Unknown Atheros device [ver=%d, rev=%d, phy_id=%04x%04x]\n",
@@ -170,8 +175,10 @@ ar8216_id_chip(struct ar8216_priv *priv)
                        mdiobus_read(priv->phy->bus, priv->phy->addr, 2),
                        mdiobus_read(priv->phy->bus, priv->phy->addr, 3));
 
-               return UNKNOWN;
+               return -ENODEV;
        }
+
+       return 0;
 }
 
 static void
@@ -468,14 +475,22 @@ static int
 ar8216_wait_bit(struct ar8216_priv *priv, int reg, u32 mask, u32 val)
 {
        int timeout = 20;
+       u32 t = 0;
 
-       while ((priv->read(priv, reg) & mask) != val) {
-               if (timeout-- <= 0) {
-                       printk(KERN_ERR "ar8216: timeout waiting for operation to complete\n");
-                       return 1;
-               }
+       while (1) {
+               t = priv->read(priv, reg);
+               if ((t & mask) == val)
+                       return 0;
+
+               if (timeout-- <= 0)
+                       break;
+
+               udelay(10);
        }
-       return 0;
+
+       pr_err("ar8216: timeout on reg %08x: %08x & %08x != %08x\n",
+              (unsigned int) reg, t, mask, val);
+       return -ETIMEDOUT;
 }
 
 static void
@@ -623,6 +638,17 @@ ar8216_hw_apply(struct switch_dev *dev)
 }
 
 static int
+ar8216_hw_init(struct ar8216_priv *priv)
+{
+       /* XXX: undocumented magic from atheros, required! */
+       priv->write(priv, 0x38, 0xc000050e);
+
+       ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL,
+                  AR8216_GCTRL_MTU, 1518 + 8 + 2);
+       return 0;
+}
+
+static int
 ar8236_hw_init(struct ar8216_priv *priv) {
        static int initialized;
        int i;
@@ -641,6 +667,10 @@ ar8236_hw_init(struct ar8216_priv *priv) {
        }
        msleep(1000);
 
+       /* enable jumbo frames */
+       ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL,
+                  AR8316_GCTRL_MTU, 9018 + 8 + 2);
+
        initialized = true;
        return 0;
 }
@@ -705,11 +735,44 @@ ar8316_hw_init(struct ar8216_priv *priv) {
                msleep(1000);
        }
 
+       /* enable jumbo frames */
+       ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL,
+                  AR8316_GCTRL_MTU, 9018 + 8 + 2);
+
+       /* enable cpu port to receive multicast and broadcast frames */
+       priv->write(priv, AR8216_REG_FLOOD_MASK, 0x003f003f);
+
 out:
        priv->initialized = true;
        return 0;
 }
 
+static void
+ar8216_init_port(struct ar8216_priv *priv, int port)
+{
+       /* Enable port learning and tx */
+       priv->write(priv, AR8216_REG_PORT_CTRL(port),
+               AR8216_PORT_CTRL_LEARN |
+               (4 << AR8216_PORT_CTRL_STATE_S));
+
+       priv->write(priv, AR8216_REG_PORT_VLAN(port), 0);
+
+       if (port == AR8216_PORT_CPU) {
+               priv->write(priv, AR8216_REG_PORT_STATUS(port),
+                       AR8216_PORT_STATUS_LINK_UP |
+                       ((priv->chip == AR8316) ?
+                               AR8216_PORT_SPEED_1000M : AR8216_PORT_SPEED_100M) |
+                       AR8216_PORT_STATUS_TXMAC |
+                       AR8216_PORT_STATUS_RXMAC |
+                       ((priv->chip == AR8316) ? AR8216_PORT_STATUS_RXFLOW : 0) |
+                       ((priv->chip == AR8316) ? AR8216_PORT_STATUS_TXFLOW : 0) |
+                       AR8216_PORT_STATUS_DUPLEX);
+       } else {
+               priv->write(priv, AR8216_REG_PORT_STATUS(port),
+                       AR8216_PORT_STATUS_LINK_AUTO);
+       }
+}
+
 static int
 ar8216_reset_switch(struct switch_dev *dev)
 {
@@ -722,47 +785,11 @@ ar8216_reset_switch(struct switch_dev *dev)
        for (i = 0; i < AR8X16_MAX_VLANS; i++) {
                priv->vlan_id[i] = i;
        }
-       for (i = 0; i < AR8216_NUM_PORTS; i++) {
-               /* Enable port learning and tx */
-               priv->write(priv, AR8216_REG_PORT_CTRL(i),
-                       AR8216_PORT_CTRL_LEARN |
-                       (4 << AR8216_PORT_CTRL_STATE_S));
-
-               priv->write(priv, AR8216_REG_PORT_VLAN(i), 0);
-
-               /* Configure all PHYs */
-               if (i == AR8216_PORT_CPU) {
-                       priv->write(priv, AR8216_REG_PORT_STATUS(i),
-                               AR8216_PORT_STATUS_LINK_UP |
-                               ((priv->chip == AR8316) ?
-                                       AR8216_PORT_SPEED_1000M : AR8216_PORT_SPEED_100M) |
-                               AR8216_PORT_STATUS_TXMAC |
-                               AR8216_PORT_STATUS_RXMAC |
-                               ((priv->chip == AR8316) ? AR8216_PORT_STATUS_RXFLOW : 0) |
-                               ((priv->chip == AR8316) ? AR8216_PORT_STATUS_TXFLOW : 0) |
-                               AR8216_PORT_STATUS_DUPLEX);
-               } else {
-                       priv->write(priv, AR8216_REG_PORT_STATUS(i),
-                               AR8216_PORT_STATUS_LINK_AUTO);
-               }
-       }
-       /* XXX: undocumented magic from atheros, required! */
-       priv->write(priv, 0x38, 0xc000050e);
 
-       if (priv->chip == AR8216) {
-               ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL,
-                       AR8216_GCTRL_MTU, 1518 + 8 + 2);
-       } else if (priv->chip == AR8316 ||
-                  priv->chip == AR8236) {
-               /* enable jumbo frames */
-               ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL,
-                       AR8316_GCTRL_MTU, 9018 + 8 + 2);
-       }
+       /* Configure all ports */
+       for (i = 0; i < AR8216_NUM_PORTS; i++)
+               ar8216_init_port(priv, i);
 
-       if (priv->chip == AR8316) {
-               /* enable cpu port to receive multicast and broadcast frames */
-               priv->write(priv, AR8216_REG_FLOOD_MASK, 0x003f003f);
-       }
        mutex_unlock(&priv->reg_mutex);
        return ar8216_hw_apply(dev);
 }
@@ -806,7 +833,9 @@ ar8216_config_init(struct phy_device *pdev)
 
        priv->phy = pdev;
 
-       priv->chip = ar8216_id_chip(priv);
+       ret = ar8216_id_chip(priv);
+       if (ret)
+               goto err_free_priv;
 
        if (pdev->addr != 0) {
                if (priv->chip == AR8316) {
@@ -877,34 +906,26 @@ ar8216_config_init(struct phy_device *pdev)
                swdev->vlans = AR8216_NUM_VLANS;
        }
 
-       if ((ret = register_switch(&priv->dev, pdev->attached_dev)) < 0) {
-               kfree(priv);
-               goto done;
-       }
+       ret = register_switch(&priv->dev, pdev->attached_dev);
+       if (ret)
+               goto err_free_priv;
 
        priv->init = true;
 
-       if (priv->chip == AR8316) {
+       ret = 0;
+       if (priv->chip == AR8216)
+               ret = ar8216_hw_init(priv);
+       else if (priv->chip == AR8236)
+               ret = ar8236_hw_init(priv);
+       else if (priv->chip == AR8316)
                ret = ar8316_hw_init(priv);
-               if (ret) {
-                       kfree(priv);
-                       goto done;
-               }
-       }
 
-       if (priv->chip == AR8236) {
-               ret = ar8236_hw_init(priv);
-               if (ret) {
-                       kfree(priv);
-                       goto done;
-               }
-       }
+       if (ret)
+               goto err_free_priv;
 
        ret = ar8216_reset_switch(&priv->dev);
-       if (ret) {
-               kfree(priv);
-               goto done;
-       }
+       if (ret)
+               goto err_free_priv;
 
        dev->phy_ptr = priv;
 
@@ -921,7 +942,10 @@ ar8216_config_init(struct phy_device *pdev)
 
        priv->init = false;
 
-done:
+       return 0;
+
+err_free_priv:
+       kfree(priv);
        return ret;
 }
 
@@ -958,11 +982,8 @@ ar8216_read_status(struct phy_device *phydev)
        /* flush the address translation unit */
        mutex_lock(&priv->reg_mutex);
        ret = ar8216_wait_bit(priv, AR8216_REG_ATU, AR8216_ATU_ACTIVE, 0);
-
        if (!ret)
                priv->write(priv, AR8216_REG_ATU, AR8216_ATU_OP_FLUSH);
-       else
-               ret = -ETIMEDOUT;
        mutex_unlock(&priv->reg_mutex);
 
        phydev->state = PHY_RUNNING;
@@ -985,14 +1006,9 @@ static int
 ar8216_probe(struct phy_device *pdev)
 {
        struct ar8216_priv priv;
-       u16 chip;
 
        priv.phy = pdev;
-       chip = ar8216_id_chip(&priv);
-       if (chip == UNKNOWN)
-               return -ENODEV;
-
-       return 0;
+       return ar8216_id_chip(&priv);
 }
 
 static void