generic: swconfig: add a generic get_port_link implementation

[openwrt.git] / target / linux / generic / files / drivers / net / phy / rtl8366_smi.c

diff --git a/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c b/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c
index 9b70a92..e48ca99 100644 (file)
--- a/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c
+++ b/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c
@@ -15,6 +15,7 @@
 #include <linux/gpio.h>
 #include <linux/spinlock.h>
 #include <linux/skbuff.h>
 #include <linux/gpio.h>
 #include <linux/spinlock.h>
 #include <linux/skbuff.h>

+#include <linux/rtl8366.h>

 
 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
 #include <linux/debugfs.h>
 
 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
 #include <linux/debugfs.h>


@@ -23,11 +24,10 @@
 #include "rtl8366_smi.h"
 
 #define RTL8366_SMI_ACK_RETRY_COUNT         5
 #include "rtl8366_smi.h"
 
 #define RTL8366_SMI_ACK_RETRY_COUNT         5

-#define RTL8366_SMI_CLK_DELAY               10 /* nsec */

 
 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
 {
 
 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
 {

-       ndelay(RTL8366_SMI_CLK_DELAY);
+       ndelay(smi->clk_delay);

 }
 
 static void rtl8366_smi_start(struct rtl8366_smi *smi)
 }
 
 static void rtl8366_smi_start(struct rtl8366_smi *smi)


@@ -142,8 +142,10 @@ static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
                if (ack == 0)
                        break;
 
                if (ack == 0)
                        break;
 

-               if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT)
-                       return -EIO;
+               if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT) {
+                       dev_err(smi->parent, "ACK timeout\n");
+                       return -ETIMEDOUT;
+               }

        } while (1);
 
        return 0;
        } while (1);
 
        return 0;


@@ -155,6 +157,12 @@ static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
        return rtl8366_smi_wait_for_ack(smi);
 }
 
        return rtl8366_smi_wait_for_ack(smi);
 }
 

+static int rtl8366_smi_write_byte_noack(struct rtl8366_smi *smi, u8 data)
+{
+       rtl8366_smi_write_bits(smi, data, 8);
+       return 0;
+}
+

 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
 {
        u32 t;
 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
 {
        u32 t;


@@ -195,7 +203,7 @@ int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
        rtl8366_smi_start(smi);
 
        /* send READ command */
        rtl8366_smi_start(smi);
 
        /* send READ command */

-       ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x01);
+       ret = rtl8366_smi_write_byte(smi, smi->cmd_read);

        if (ret)
                goto out;
 
        if (ret)
                goto out;
 


@@ -226,7 +234,8 @@ int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
 }
 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
 
 }
 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
 

-int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
+static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
+                                  u32 addr, u32 data, bool ack)

 {
        unsigned long flags;
        int ret;
 {
        unsigned long flags;
        int ret;


@@ -236,7 +245,7 @@ int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
        rtl8366_smi_start(smi);
 
        /* send WRITE command */
        rtl8366_smi_start(smi);
 
        /* send WRITE command */

-       ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x00);
+       ret = rtl8366_smi_write_byte(smi, smi->cmd_write);

        if (ret)
                goto out;
 
        if (ret)
                goto out;
 


@@ -256,7 +265,10 @@ int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
                goto out;
 
        /* write DATA[15:8] */
                goto out;
 
        /* write DATA[15:8] */

-       ret = rtl8366_smi_write_byte(smi, data >> 8);
+       if (ack)
+               ret = rtl8366_smi_write_byte(smi, data >> 8);
+       else
+               ret = rtl8366_smi_write_byte_noack(smi, data >> 8);

        if (ret)
                goto out;
 
        if (ret)
                goto out;
 


@@ -268,8 +280,19 @@ int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 
        return ret;
 }
 
        return ret;
 }

+
+int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
+{
+       return __rtl8366_smi_write_reg(smi, addr, data, true);
+}

 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 
 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 

+int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
+{
+       return __rtl8366_smi_write_reg(smi, addr, data, false);
+}
+EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
+

 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
 {
        u32 t;
 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
 {
        u32 t;


@@ -448,7 +471,7 @@ static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
        return -ENOSPC;
 }
 
        return -ENOSPC;
 }
 

-static int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
+int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)

 {
        int err;
 
 {
        int err;
 


@@ -465,6 +488,7 @@ static int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
 
        return err;
 }
 
        return err;
 }

+EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);

 
 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
 {
 
 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
 {


@@ -486,6 +510,21 @@ static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
        return 0;
 }
 
        return 0;
 }
 

+int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
+{
+       int port;
+       int err;
+
+       for (port = 0; port < smi->num_ports; port++) {
+               err = smi->ops->enable_port(smi, port, enable);
+               if (err)
+                       return err;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
+

 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
 {
        struct rtl8366_vlan_mc vlanmc;
 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
 {
        struct rtl8366_vlan_mc vlanmc;


@@ -507,25 +546,38 @@ int rtl8366_reset_vlan(struct rtl8366_smi *smi)
                        return err;
        }
 
                        return err;
        }
 

-       for (i = 0; i < smi->num_ports; i++) {
-               if (i == smi->cpu_port)
-                       continue;
+       return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);

 
 

-               err = rtl8366_set_vlan(smi, (i + 1),
-                                       (1 << i) | (1 << smi->cpu_port),
-                                       (1 << i) | (1 << smi->cpu_port),
-                                       0);
+static int rtl8366_init_vlan(struct rtl8366_smi *smi)
+{
+       int port;
+       int err;
+
+       err = rtl8366_reset_vlan(smi);
+       if (err)
+               return err;
+
+       for (port = 0; port < smi->num_ports; port++) {
+               u32 mask;
+
+               if (port == smi->cpu_port)
+                       mask = (1 << smi->num_ports) - 1;
+               else
+                       mask = (1 << port) | (1 << smi->cpu_port);
+
+               err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);

                if (err)
                        return err;
 
                if (err)
                        return err;
 

-               err = rtl8366_set_pvid(smi, i, (i + 1));
+               err = rtl8366_set_pvid(smi, port, (port + 1));

                if (err)
                        return err;
        }
 
                if (err)
                        return err;
        }
 

-       return 0;
+       return rtl8366_enable_vlan(smi, 1);

 }
 }

-EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);

 
 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
 
 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
 int rtl8366_debugfs_open(struct inode *inode, struct file *file)


@@ -561,6 +613,43 @@ static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 }
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 }
 

+#define RTL8366_VLAN4K_PAGE_SIZE       64
+#define RTL8366_VLAN4K_NUM_PAGES       (4096 / RTL8366_VLAN4K_PAGE_SIZE)
+
+static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
+                                           char __user *user_buf,
+                                           size_t count, loff_t *ppos)
+{
+       struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+       int i, len = 0;
+       int offset;
+       char *buf = smi->buf;
+
+       if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
+               len += snprintf(buf + len, sizeof(smi->buf) - len,
+                               "invalid page: %u\n", smi->dbg_vlan_4k_page);
+               return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+       }
+
+       len += snprintf(buf + len, sizeof(smi->buf) - len,
+                       "%4s %6s %6s %3s\n",
+                       "vid", "member", "untag", "fid");
+
+       offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
+       for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
+               struct rtl8366_vlan_4k vlan4k;
+
+               smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
+
+               len += snprintf(buf + len, sizeof(smi->buf) - len,
+                               "%4d 0x%04x 0x%04x %3d\n",
+                               vlan4k.vid, vlan4k.member,
+                               vlan4k.untag, vlan4k.fid);
+       }
+
+       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+

 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)
 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)


@@ -703,6 +792,12 @@ static const struct file_operations fops_rtl8366_vlan_mc = {
        .owner  = THIS_MODULE
 };
 
        .owner  = THIS_MODULE
 };
 

+static const struct file_operations fops_rtl8366_vlan_4k = {
+       .read   = rtl8366_read_debugfs_vlan_4k,
+       .open   = rtl8366_debugfs_open,
+       .owner  = THIS_MODULE
+};
+

 static const struct file_operations fops_rtl8366_pvid = {
        .read   = rtl8366_read_debugfs_pvid,
        .open   = rtl8366_debugfs_open,
 static const struct file_operations fops_rtl8366_pvid = {
        .read   = rtl8366_read_debugfs_pvid,
        .open   = rtl8366_debugfs_open,


@@ -754,6 +849,22 @@ static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
                return;
        }
 
                return;
        }
 

+       node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
+                                 &smi->dbg_vlan_4k_page);
+       if (!node) {
+               dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+                       "vlan_4k_page");
+               return;
+       }
+
+       node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
+                                  &fops_rtl8366_vlan_4k);
+       if (!node) {
+               dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+                       "vlan_4k");
+               return;
+       }
+

        node = debugfs_create_file("pvid", S_IRUSR, root, smi,
                                   &fops_rtl8366_pvid);
        if (!node) {
        node = debugfs_create_file("pvid", S_IRUSR, root, smi,
                                   &fops_rtl8366_pvid);
        if (!node) {


@@ -946,6 +1057,7 @@ int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
        struct switch_port *port;
        u32 member = 0;
        u32 untag = 0;
        struct switch_port *port;
        u32 member = 0;
        u32 untag = 0;

+       int err;

        int i;
 
        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
        int i;
 
        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))


@@ -957,12 +1069,66 @@ int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 
                if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
                        untag |= BIT(port->id);
 
                if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
                        untag |= BIT(port->id);

+
+               /*
+                * To ensure that we have a valid MC entry for this VLAN,
+                * initialize the port VLAN ID here.
+                */
+               err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
+               if (err < 0)
+                       return err;

        }
 
        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
 }
 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
 
        }
 
        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
 }
 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
 

+int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
+                           const struct switch_attr *attr,
+                           struct switch_val *val)
+{
+       struct rtl8366_vlan_4k vlan4k;
+       struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
+       int err;
+
+       if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
+               return -EINVAL;
+
+       err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
+       if (err)
+               return err;
+
+       val->value.i = vlan4k.fid;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
+
+int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
+                           const struct switch_attr *attr,
+                           struct switch_val *val)
+{
+       struct rtl8366_vlan_4k vlan4k;
+       struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
+       int err;
+
+       if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
+               return -EINVAL;
+
+       if (val->value.i < 0 || val->value.i > attr->max)
+               return -EINVAL;
+
+       err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
+       if (err)
+               return err;
+
+       return rtl8366_set_vlan(smi, val->port_vlan,
+                               vlan4k.member,
+                               vlan4k.untag,
+                               val->value.i);
+}
+EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
+

 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
                               const struct switch_attr *attr,
                               struct switch_val *val)
 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
                               const struct switch_attr *attr,
                               struct switch_val *val)


@@ -1017,27 +1183,89 @@ struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
 }
 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
 
 }
 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
 

-int rtl8366_smi_init(struct rtl8366_smi *smi)
+static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)

 {
        int err;
 
 {
        int err;
 

-       if (!smi->ops)
-               return -EINVAL;
-
-       err = gpio_request(smi->gpio_sda, dev_name(smi->parent));
+       err = gpio_request(smi->gpio_sda, name);

        if (err) {
        if (err) {

-               dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
+               printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",

                        smi->gpio_sda, err);
                goto err_out;
        }
 
                        smi->gpio_sda, err);
                goto err_out;
        }
 

-       err = gpio_request(smi->gpio_sck, dev_name(smi->parent));
+       err = gpio_request(smi->gpio_sck, name);

        if (err) {
        if (err) {

-               dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
+               printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",

                        smi->gpio_sck, err);
                goto err_free_sda;
        }
 
                        smi->gpio_sck, err);
                goto err_free_sda;
        }
 

+       spin_lock_init(&smi->lock);
+       return 0;
+
+ err_free_sda:
+       gpio_free(smi->gpio_sda);
+ err_out:
+       return err;
+}
+
+static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
+{
+       gpio_free(smi->gpio_sck);
+       gpio_free(smi->gpio_sda);
+}
+
+enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
+{
+       static struct rtl8366_smi smi;
+       enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
+       u32 reg = 0;
+
+       memset(&smi, 0, sizeof(smi));
+       smi.gpio_sda = pdata->gpio_sda;
+       smi.gpio_sck = pdata->gpio_sck;
+       smi.clk_delay = 10;
+       smi.cmd_read  = 0xa9;
+       smi.cmd_write = 0xa8;
+
+       if (__rtl8366_smi_init(&smi, "rtl8366"))
+               goto out;
+
+       if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
+               goto cleanup;
+
+       switch(reg) {
+       case 0x6027:
+               printk("Found an RTL8366S switch\n");
+               type = RTL8366_TYPE_S;
+               break;
+       case 0x5937:
+               printk("Found an RTL8366RB switch\n");
+               type = RTL8366_TYPE_RB;
+               break;
+       default:
+               printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
+               break;
+       }
+
+cleanup:
+       __rtl8366_smi_cleanup(&smi);
+out:
+       return type;
+}
+
+int rtl8366_smi_init(struct rtl8366_smi *smi)
+{
+       int err;
+
+       if (!smi->ops)
+               return -EINVAL;
+
+       err = __rtl8366_smi_init(smi, dev_name(smi->parent));
+       if (err)
+               goto err_out;
+

        spin_lock_init(&smi->lock);
 
        dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
        spin_lock_init(&smi->lock);
 
        dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",


@@ -1055,6 +1283,17 @@ int rtl8366_smi_init(struct rtl8366_smi *smi)
                goto err_free_sck;
        }
 
                goto err_free_sck;
        }
 

+       err = rtl8366_init_vlan(smi);
+       if (err) {
+               dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
+                       err);
+               goto err_free_sck;
+       }
+
+       err = rtl8366_enable_all_ports(smi, 1);
+       if (err)
+               goto err_free_sck;
+

        err = rtl8366_smi_mii_init(smi);
        if (err)
                goto err_free_sck;
        err = rtl8366_smi_mii_init(smi);
        if (err)
                goto err_free_sck;


@@ -1064,9 +1303,7 @@ int rtl8366_smi_init(struct rtl8366_smi *smi)
        return 0;
 
  err_free_sck:
        return 0;
 
  err_free_sck:

-       gpio_free(smi->gpio_sck);
- err_free_sda:
-       gpio_free(smi->gpio_sda);
+       __rtl8366_smi_cleanup(smi);

  err_out:
        return err;
 }
  err_out:
        return err;
 }