rtl8366_smi: move chip specific stuff into its own struct

SVN-Revision: 19277

diff --git a/target/linux/ar71xx/files/drivers/net/phy/rtl8366_smi.c b/target/linux/ar71xx/files/drivers/net/phy/rtl8366_smi.c
index abd1af0ae8d5c7abf431edb042afd222c75c07b9..9ecf6bfbc3ff0a9cf5707ee11ffbf68920056a1a 100644 (file)
--- a/target/linux/ar71xx/files/drivers/net/phy/rtl8366_smi.c
+++ b/target/linux/ar71xx/files/drivers/net/phy/rtl8366_smi.c
@@ -209,16 +209,21 @@ static const char *MIBCOUNTERS[] = {
 };
 
 struct rtl8366_smi {
 };
 
 struct rtl8366_smi {

-       struct device                      *parent;
-       unsigned int                       gpio_sda;
-       unsigned int                       gpio_sck;
-       spinlock_t                         lock;
-       struct mii_bus                     *mii_bus;
-       struct switch_dev                  dev;
-       int                                mii_irq[PHY_MAX_ADDR];
-       char                               buf[4096];
+       struct device           *parent;
+       unsigned int            gpio_sda;
+       unsigned int            gpio_sck;
+       spinlock_t              lock;
+};
+
+struct rtl8366s {
+       struct device           *parent;
+       struct rtl8366_smi      smi;
+       struct mii_bus          *mii_bus;
+       int                     mii_irq[PHY_MAX_ADDR];
+       struct switch_dev       dev;
+       char                    buf[4096];

 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS

-       struct dentry                      *debugfs_root;
+       struct dentry           *debugfs_root;

 #endif
 };
 
 #endif
 };
 


@@ -226,9 +231,9 @@ struct rtl8366_smi {
 u16 g_dbg_reg;
 #endif
 
 u16 g_dbg_reg;
 #endif
 

-static inline struct rtl8366_smi *sw_to_rtl8366(struct switch_dev *sw)
+static inline struct rtl8366s *sw_to_rtl8366s(struct switch_dev *sw)

 {
 {

-       return container_of(sw, struct rtl8366_smi, dev);
+       return container_of(sw, struct rtl8366s, dev);

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


@@ -477,9 +482,10 @@ static int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
        return ret;
 }
 
        return ret;
 }
 

-static int rtl8366_smi_read_phy_reg(struct rtl8366_smi *smi,
+static int rtl8366_smi_read_phy_reg(struct rtl8366s *rtl,

                                    u32 phy_no, u32 page, u32 addr, u32 *data)
 {
                                    u32 phy_no, u32 page, u32 addr, u32 *data)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 reg;
        int ret;
 
        u32 reg;
        int ret;
 


@@ -512,9 +518,10 @@ static int rtl8366_smi_read_phy_reg(struct rtl8366_smi *smi,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366_smi_write_phy_reg(struct rtl8366_smi *smi,
+static int rtl8366_smi_write_phy_reg(struct rtl8366s *rtl,

                                     u32 phy_no, u32 page, u32 addr, u32 data)
 {
                                     u32 phy_no, u32 page, u32 addr, u32 data)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 reg;
        int ret;
 
        u32 reg;
        int ret;
 


@@ -543,9 +550,10 @@ static int rtl8366_smi_write_phy_reg(struct rtl8366_smi *smi,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366_get_mib_counter(struct rtl8366_smi *smi, int counter,
+static int rtl8366_get_mib_counter(struct rtl8366s *rtl, int counter,

                                   int port, unsigned long long *val)
 {
                                   int port, unsigned long long *val)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        int i;
        int err;
        u32 addr, data, regoffset;
        int i;
        int err;
        u32 addr, data, regoffset;


@@ -606,9 +614,10 @@ static int rtl8366_get_mib_counter(struct rtl8366_smi *smi, int counter,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366s_get_vlan_4k_entry(struct rtl8366_smi *smi, u32 vid,
+static int rtl8366s_get_vlan_4k_entry(struct rtl8366s *rtl, u32 vid,

                                      struct rtl8366s_vlan4kentry *vlan4k)
 {
                                      struct rtl8366s_vlan4kentry *vlan4k)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        int err;
        u32 data;
        u16 *tableaddr;
        int err;
        u32 data;
        u16 *tableaddr;


@@ -651,9 +660,10 @@ static int rtl8366s_get_vlan_4k_entry(struct rtl8366_smi *smi, u32 vid,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366s_set_vlan_4k_entry(struct rtl8366_smi *smi,
+static int rtl8366s_set_vlan_4k_entry(struct rtl8366s *rtl,

                                      const struct rtl8366s_vlan4kentry *vlan4k)
 {
                                      const struct rtl8366s_vlan4kentry *vlan4k)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        int err;
        u32 data;
        u16 *tableaddr;
        int err;
        u32 data;
        u16 *tableaddr;


@@ -688,9 +698,10 @@ static int rtl8366s_set_vlan_4k_entry(struct rtl8366_smi *smi,
        return err;
 }
 
        return err;
 }
 

-static int rtl8366s_get_vlan_member_config(struct rtl8366_smi *smi, u32 index,
+static int rtl8366s_get_vlan_member_config(struct rtl8366s *rtl, u32 index,

                                           struct rtl8366s_vlanconfig *vlanmc)
 {
                                           struct rtl8366s_vlanconfig *vlanmc)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        int err;
        u32 addr;
        u32 data;
        int err;
        u32 addr;
        u32 data;


@@ -721,10 +732,11 @@ static int rtl8366s_get_vlan_member_config(struct rtl8366_smi *smi, u32 index,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366s_set_vlan_member_config(struct rtl8366_smi *smi, u32 index,
+static int rtl8366s_set_vlan_member_config(struct rtl8366s *rtl, u32 index,

                                           const struct rtl8366s_vlanconfig
                                           *vlanmc)
 {
                                           const struct rtl8366s_vlanconfig
                                           *vlanmc)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        int err;
        u32 addr;
        u32 data;
        int err;
        u32 addr;
        u32 data;


@@ -759,9 +771,10 @@ static int rtl8366s_set_vlan_member_config(struct rtl8366_smi *smi, u32 index,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366_get_port_vlan_index(struct rtl8366_smi *smi, int port,
+static int rtl8366_get_port_vlan_index(struct rtl8366s *rtl, int port,

                                       int *val)
 {
                                       int *val)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data;
        int err;
 
        u32 data;
        int err;
 


@@ -780,18 +793,18 @@ static int rtl8366_get_port_vlan_index(struct rtl8366_smi *smi, int port,
 
 }
 
 
 }
 

-static int rtl8366_get_vlan_port_pvid(struct rtl8366_smi *smi, int port,
+static int rtl8366_get_vlan_port_pvid(struct rtl8366s *rtl, int port,

                                      int *val)
 {
        struct rtl8366s_vlanconfig vlanmc;
        int err;
        int index;
 
                                      int *val)
 {
        struct rtl8366s_vlanconfig vlanmc;
        int err;
        int index;
 

-       err = rtl8366_get_port_vlan_index(smi, port, &index);
+       err = rtl8366_get_port_vlan_index(rtl, port, &index);

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

-       err = rtl8366s_get_vlan_member_config(smi, index, &vlanmc);
+       err = rtl8366s_get_vlan_member_config(rtl, index, &vlanmc);

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


@@ -799,9 +812,10 @@ static int rtl8366_get_vlan_port_pvid(struct rtl8366_smi *smi, int port,
        return 0;
 }
 
        return 0;
 }
 

-static int rtl8366_set_port_vlan_index(struct rtl8366_smi *smi, int port,
+static int rtl8366_set_port_vlan_index(struct rtl8366s *rtl, int port,

                                       int index)
 {
                                       int index)
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data;
        int err;
 
        u32 data;
        int err;
 


@@ -823,7 +837,7 @@ static int rtl8366_set_port_vlan_index(struct rtl8366_smi *smi, int port,
        return err;
 }
 
        return err;
 }
 

-static int rtl8366_set_vlan_port_pvid(struct rtl8366_smi *smi, int port,
+static int rtl8366_set_vlan_port_pvid(struct rtl8366s *rtl, int port,

                                      int val)
 {
        int i;
                                      int val)
 {
        int i;


@@ -834,25 +848,25 @@ static int rtl8366_set_vlan_port_pvid(struct rtl8366_smi *smi, int port,
                return -EINVAL;
 
        /* Updating the 4K entry; lookup it and change the port member set */
                return -EINVAL;
 
        /* Updating the 4K entry; lookup it and change the port member set */

-       rtl8366s_get_vlan_4k_entry(smi, val, &vlan4k);
+       rtl8366s_get_vlan_4k_entry(rtl, val, &vlan4k);

        vlan4k.member |= ((1 << port) | RTL8366_PORT_CPU);
        vlan4k.untag = RTL8366_PORT_ALL_BUT_CPU;
        vlan4k.member |= ((1 << port) | RTL8366_PORT_CPU);
        vlan4k.untag = RTL8366_PORT_ALL_BUT_CPU;

-       rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
+       rtl8366s_set_vlan_4k_entry(rtl, &vlan4k);

 
        /*
         * For the 16 entries more work needs to be done. First see if such
         * VID is already there and change it
         */
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
 
        /*
         * For the 16 entries more work needs to be done. First see if such
         * VID is already there and change it
         */
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {

-               rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
+               rtl8366s_get_vlan_member_config(rtl, i, &vlanmc);

 
                /* Try to find an existing vid and update port member set */
                if (val == vlanmc.vid) {
                        vlanmc.member |= ((1 << port) | RTL8366_PORT_CPU);
 
                /* Try to find an existing vid and update port member set */
                if (val == vlanmc.vid) {
                        vlanmc.member |= ((1 << port) | RTL8366_PORT_CPU);

-                       rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
+                       rtl8366s_set_vlan_member_config(rtl, i, &vlanmc);

 
                        /* Now update PVID register settings */
 
                        /* Now update PVID register settings */

-                       rtl8366_set_port_vlan_index(smi, port, i);
+                       rtl8366_set_port_vlan_index(rtl, port, i);

 
                        return 0;
                }
 
                        return 0;
                }


@@ -863,7 +877,7 @@ static int rtl8366_set_vlan_port_pvid(struct rtl8366_smi *smi, int port,
         * has no member ports) with new one
         */
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
         * has no member ports) with new one
         */
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {

-               rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
+               rtl8366s_get_vlan_member_config(rtl, i, &vlanmc);

 
                /*
                 * See if this vlan member configuration is unused. It is
 
                /*
                 * See if this vlan member configuration is unused. It is


@@ -876,24 +890,25 @@ static int rtl8366_set_vlan_port_pvid(struct rtl8366_smi *smi, int port,
                        vlanmc.member = ((1 << port) | RTL8366_PORT_CPU);
                        vlanmc.fid = 0;
 
                        vlanmc.member = ((1 << port) | RTL8366_PORT_CPU);
                        vlanmc.fid = 0;
 

-                       rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
+                       rtl8366s_set_vlan_member_config(rtl, i, &vlanmc);

 
                        /* Now update PVID register settings */
 
                        /* Now update PVID register settings */

-                       rtl8366_set_port_vlan_index(smi, port, i);
+                       rtl8366_set_port_vlan_index(rtl, port, i);

 
                        return 0;
                }
        }
 
 
                        return 0;
                }
        }
 

-       dev_err(smi->parent,
+       dev_err(rtl->parent,

                "All 16 vlan member configurations are in use\n");
 
        return -EINVAL;
 }
 
 
                "All 16 vlan member configurations are in use\n");
 
        return -EINVAL;
 }
 
 

-static int rtl8366_vlan_set_vlan(struct rtl8366_smi *smi, int enable)
+static int rtl8366_vlan_set_vlan(struct rtl8366s *rtl, int enable)

 {
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
        u32 data = 0;
 
        rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);


@@ -906,8 +921,9 @@ static int rtl8366_vlan_set_vlan(struct rtl8366_smi *smi, int enable)
        return rtl8366_smi_write_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, data);
 }
 
        return rtl8366_smi_write_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, data);
 }
 

-static int rtl8366_vlan_set_4ktable(struct rtl8366_smi *smi, int enable)
+static int rtl8366_vlan_set_4ktable(struct rtl8366s *rtl, int enable)

 {
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, &data);
        u32 data = 0;
 
        rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, &data);


@@ -920,7 +936,7 @@ static int rtl8366_vlan_set_4ktable(struct rtl8366_smi *smi, int enable)
        return rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, data);
 }
 
        return rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, data);
 }
 

-static int rtl8366s_reset_vlan(struct rtl8366_smi *smi)
+static int rtl8366s_reset_vlan(struct rtl8366s *rtl)

 {
        struct rtl8366s_vlan4kentry vlan4k;
        struct rtl8366s_vlanconfig vlanmc;
 {
        struct rtl8366s_vlan4kentry vlan4k;
        struct rtl8366s_vlanconfig vlanmc;


@@ -934,7 +950,7 @@ static int rtl8366s_reset_vlan(struct rtl8366_smi *smi)
        vlanmc.untag = 0;
        vlanmc.fid = 0;
        for (i = 0; i < RTL8366_NUM_VLANS; i++) {
        vlanmc.untag = 0;
        vlanmc.fid = 0;
        for (i = 0; i < RTL8366_NUM_VLANS; i++) {

-               err = rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
+               err = rtl8366s_set_vlan_member_config(rtl, i, &vlanmc);

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


@@ -944,13 +960,13 @@ static int rtl8366s_reset_vlan(struct rtl8366_smi *smi)
        vlan4k.member = RTL8366_PORT_ALL;
        vlan4k.untag = RTL8366_PORT_ALL;
        vlan4k.fid = 0;
        vlan4k.member = RTL8366_PORT_ALL;
        vlan4k.untag = RTL8366_PORT_ALL;
        vlan4k.fid = 0;

-       err = rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
+       err = rtl8366s_set_vlan_4k_entry(rtl, &vlan4k);

        if (err)
                return err;
 
        /* Set all ports PVID to default VLAN */
        for (i = 0; i < RTL8366_NUM_PORTS; i++) {
        if (err)
                return err;
 
        /* Set all ports PVID to default VLAN */
        for (i = 0; i < RTL8366_NUM_PORTS; i++) {

-               err = rtl8366_set_vlan_port_pvid(smi, i, 0);
+               err = rtl8366_set_vlan_port_pvid(rtl, i, 0);

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


@@ -969,46 +985,46 @@ static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {

-       struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+       struct rtl8366s *rtl = (struct rtl8366s *)file->private_data;

        int i, j, len = 0;
        int i, j, len = 0;

-       char *buf = smi->buf;
+       char *buf = rtl->buf;

 
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "MIB Counters:\n");
-       len += snprintf(buf + len, sizeof(smi->buf) - len, "Counter"
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "MIB Counters:\n");
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "Counter"

                        "                            "
                        "Port 0 \t\t Port 1 \t\t Port 2 \t\t Port 3 \t\t "
                        "Port 4\n");
 
        for (i = 0; i < 33; ++i) {
                        "                            "
                        "Port 0 \t\t Port 1 \t\t Port 2 \t\t Port 3 \t\t "
                        "Port 4\n");
 
        for (i = 0; i < 33; ++i) {

-               len += snprintf(buf + len, sizeof(smi->buf) - len, "%d:%s ",
+               len += snprintf(buf + len, sizeof(rtl->buf) - len, "%d:%s ",

                                i, MIBCOUNTERS[i]);
                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
                        unsigned long long counter = 0;
 
                                i, MIBCOUNTERS[i]);
                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
                        unsigned long long counter = 0;
 

-                       if (!rtl8366_get_mib_counter(smi, i, j, &counter))
+                       if (!rtl8366_get_mib_counter(rtl, i, j, &counter))

                                len += snprintf(buf + len,
                                len += snprintf(buf + len,

-                                               sizeof(smi->buf) - len,
+                                               sizeof(rtl->buf) - len,

                                                "[%llu]", counter);
                        else
                                len += snprintf(buf + len,
                                                "[%llu]", counter);
                        else
                                len += snprintf(buf + len,

-                                               sizeof(smi->buf) - len,
+                                               sizeof(rtl->buf) - len,

                                                "[error]");
 
                        if (j != RTL8366_NUM_PORTS - 1) {
                                if (counter < 100000)
                                        len += snprintf(buf + len,
                                                "[error]");
 
                        if (j != RTL8366_NUM_PORTS - 1) {
                                if (counter < 100000)
                                        len += snprintf(buf + len,

-                                                       sizeof(smi->buf) - len,
+                                                       sizeof(rtl->buf) - len,

                                                        "\t");
 
                                len += snprintf(buf + len,
                                                        "\t");
 
                                len += snprintf(buf + len,

-                                               sizeof(smi->buf) - len,
+                                               sizeof(rtl->buf) - len,

                                                "\t");
                        }
                }
                                                "\t");
                        }
                }

-               len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+               len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");

        }
 
        }
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");

 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 }
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 }


@@ -1017,36 +1033,36 @@ static ssize_t rtl8366_read_debugfs_vlan(struct file *file,
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {
                                         char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {

-       struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+       struct rtl8366s *rtl = (struct rtl8366s *)file->private_data;

        int i, j, len = 0;
        int i, j, len = 0;

-       char *buf = smi->buf;
+       char *buf = rtl->buf;

 
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "VLAN Member Config:\n");
                        "VLAN Member Config:\n");

-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "\t id \t vid \t prio \t member \t untag  \t fid "
                        "\tports\n");
 
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
                struct rtl8366s_vlanconfig vlanmc;
 
                        "\t id \t vid \t prio \t member \t untag  \t fid "
                        "\tports\n");
 
        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
                struct rtl8366s_vlanconfig vlanmc;
 

-               rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
+               rtl8366s_get_vlan_member_config(rtl, i, &vlanmc);

 
 

-               len += snprintf(buf + len, sizeof(smi->buf) - len,
+               len += snprintf(buf + len, sizeof(rtl->buf) - len,

                                "\t[%d] \t %d \t %d \t 0x%04x \t 0x%04x \t %d "
                                "\t", i, vlanmc.vid, vlanmc.priority,
                                vlanmc.member, vlanmc.untag, vlanmc.fid);
 
                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
                        int index = 0;
                                "\t[%d] \t %d \t %d \t 0x%04x \t 0x%04x \t %d "
                                "\t", i, vlanmc.vid, vlanmc.priority,
                                vlanmc.member, vlanmc.untag, vlanmc.fid);
 
                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
                        int index = 0;

-                       if (!rtl8366_get_port_vlan_index(smi, j, &index)) {
+                       if (!rtl8366_get_port_vlan_index(rtl, j, &index)) {

                                if (index == i)
                                        len += snprintf(buf + len,
                                if (index == i)
                                        len += snprintf(buf + len,

-                                                       sizeof(smi->buf) - len,
+                                                       sizeof(rtl->buf) - len,

                                                        "%d", j);
                        }
                }
                                                        "%d", j);
                        }
                }

-               len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+               len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");

        }
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
        }
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);


@@ -1056,21 +1072,22 @@ static ssize_t rtl8366_read_debugfs_reg(struct file *file,
                                        char __user *user_buf,
                                        size_t count, loff_t *ppos)
 {
                                        char __user *user_buf,
                                        size_t count, loff_t *ppos)
 {

-       struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+       struct rtl8366s *rtl = (struct rtl8366s *)file->private_data;
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 t, reg = g_dbg_reg;
        int err, len = 0;
        u32 t, reg = g_dbg_reg;
        int err, len = 0;

-       char *buf = smi->buf;
+       char *buf = rtl->buf;

 
 

-       memset(buf, '\0', sizeof(smi->buf));
+       memset(buf, '\0', sizeof(rtl->buf));

 
        err = rtl8366_smi_read_reg(smi, reg, &t);
        if (err) {
 
        err = rtl8366_smi_read_reg(smi, reg, &t);
        if (err) {

-               len += snprintf(buf, sizeof(smi->buf),
+               len += snprintf(buf, sizeof(rtl->buf),

                                "Read failed (reg: 0x%04x)\n", reg);
                return simple_read_from_buffer(user_buf, count, ppos, buf, len);
        }
 
                                "Read failed (reg: 0x%04x)\n", reg);
                return simple_read_from_buffer(user_buf, count, ppos, buf, len);
        }
 

-       len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
+       len += snprintf(buf, sizeof(rtl->buf), "reg = 0x%04x, val = 0x%04x\n",

                        reg, t);
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
                        reg, t);
 
        return simple_read_from_buffer(user_buf, count, ppos, buf, len);


@@ -1080,16 +1097,17 @@ static ssize_t rtl8366_write_debugfs_reg(struct file *file,
                                         const char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {
                                         const char __user *user_buf,
                                         size_t count, loff_t *ppos)
 {

-       struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+       struct rtl8366s *rtl = (struct rtl8366s *)file->private_data;
+       struct rtl8366_smi *smi = &rtl->smi;

        unsigned long data;
        u32 reg = g_dbg_reg;
        int err;
        size_t len;
        unsigned long data;
        u32 reg = g_dbg_reg;
        int err;
        size_t len;

-       char *buf = smi->buf;
+       char *buf = rtl->buf;

 
 

-       len = min(count, sizeof(smi->buf) - 1);
+       len = min(count, sizeof(rtl->buf) - 1);

        if (copy_from_user(buf, user_buf, len)) {
        if (copy_from_user(buf, user_buf, len)) {

-               dev_err(smi->parent, "copy from user failed\n");
+               dev_err(rtl->parent, "copy from user failed\n");

                return -EFAULT;
        }
 
                return -EFAULT;
        }
 


@@ -1099,11 +1117,11 @@ static ssize_t rtl8366_write_debugfs_reg(struct file *file,
 
 
        if (strict_strtoul(buf, 16, &data)) {
 
 
        if (strict_strtoul(buf, 16, &data)) {

-               dev_err(smi->parent, "Invalid reg value %s\n", buf);
+               dev_err(rtl->parent, "Invalid reg value %s\n", buf);

        } else {
                err = rtl8366_smi_write_reg(smi, reg, data);
                if (err) {
        } else {
                err = rtl8366_smi_write_reg(smi, reg, data);
                if (err) {

-                       dev_err(smi->parent,
+                       dev_err(rtl->parent,

                                "writing reg 0x%04x val 0x%04lx failed\n",
                                reg, data);
                }
                                "writing reg 0x%04x val 0x%04lx failed\n",
                                reg, data);
                }


@@ -1131,68 +1149,69 @@ static const struct file_operations fops_rtl8366_mibs = {
        .owner = THIS_MODULE
 };
 
        .owner = THIS_MODULE
 };
 

-static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
+static void rtl8366_debugfs_init(struct rtl8366s *rtl)

 {
        struct dentry *node;
        struct dentry *root;
 
 {
        struct dentry *node;
        struct dentry *root;
 

-       if (!smi->debugfs_root)
-               smi->debugfs_root = debugfs_create_dir("rtl8366s", NULL);
+       if (!rtl->debugfs_root)
+               rtl->debugfs_root = debugfs_create_dir("rtl8366s", NULL);

 
 

-       if (!smi->debugfs_root) {
-               dev_err(smi->parent, "Unable to create debugfs dir\n");
+       if (!rtl->debugfs_root) {
+               dev_err(rtl->parent, "Unable to create debugfs dir\n");

                return;
        }
                return;
        }

-       root = smi->debugfs_root;
+       root = rtl->debugfs_root;

 
        node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &g_dbg_reg);
        if (!node) {
 
        node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &g_dbg_reg);
        if (!node) {

-               dev_err(smi->parent, "Creating debugfs file reg failed\n");
+               dev_err(rtl->parent, "Creating debugfs file reg failed\n");

                return;
        }
 
                return;
        }
 

-       node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
+       node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, rtl,

                                   &fops_rtl8366_regs);
        if (!node) {
                                   &fops_rtl8366_regs);
        if (!node) {

-               dev_err(smi->parent, "Creating debugfs file val failed\n");
+               dev_err(rtl->parent, "Creating debugfs file val failed\n");

                return;
        }
 
                return;
        }
 

-       node = debugfs_create_file("vlan", S_IRUSR, root, smi,
+       node = debugfs_create_file("vlan", S_IRUSR, root, rtl,

                                   &fops_rtl8366_vlan);
        if (!node) {
                                   &fops_rtl8366_vlan);
        if (!node) {

-               dev_err(smi->parent,
+               dev_err(rtl->parent,

                        "Creating debugfs file vlan failed\n");
                return;
        }
 
                        "Creating debugfs file vlan failed\n");
                return;
        }
 

-       node = debugfs_create_file("mibs", S_IRUSR, root, smi,
+       node = debugfs_create_file("mibs", S_IRUSR, root, rtl,

                                   &fops_rtl8366_mibs);
        if (!node) {
                                   &fops_rtl8366_mibs);
        if (!node) {

-               dev_err(smi->parent,
+               dev_err(rtl->parent,

                        "Creating debugfs file mibs failed\n");
                return;
        }
 }
 
                        "Creating debugfs file mibs failed\n");
                return;
        }
 }
 

-static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
+static void rtl8366_debugfs_remove(struct rtl8366s *rtl)

 {
 {

-       if (smi->debugfs_root) {
-               debugfs_remove_recursive(smi->debugfs_root);
-               smi->debugfs_root = NULL;
+       if (rtl->debugfs_root) {
+               debugfs_remove_recursive(rtl->debugfs_root);
+               rtl->debugfs_root = NULL;

        }
 }
 
 #else
        }
 }
 
 #else

-static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
-static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
+static inline void rtl8366_debugfs_init(struct rtl8366s *rtl) {}
+static inline void rtl8366_debugfs_remove(struct rtl8366s *rtl) {}

 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
 
 static int rtl8366_sw_reset_mibs(struct switch_dev *dev,
                                 const struct switch_attr *attr,
                                 struct switch_val *val)
 {
 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
 
 static int rtl8366_sw_reset_mibs(struct switch_dev *dev,
                                 const struct switch_attr *attr,
                                 struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        if (val->value.i == 1) {
        u32 data = 0;
 
        if (val->value.i == 1) {


@@ -1208,7 +1227,8 @@ static int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data;
 
        if (attr->ofs == 1) {
        u32 data;
 
        if (attr->ofs == 1) {


@@ -1234,7 +1254,8 @@ static int rtl8366_sw_get_blinkrate(struct switch_dev *dev,
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data;
 
        rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
        u32 data;
 
        rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);


@@ -1248,8 +1269,9 @@ static int rtl8366_sw_set_blinkrate(struct switch_dev *dev,
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {

+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data;
        u32 data;

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);

 
        if (val->value.i >= 6)
                return -EINVAL;
 
        if (val->value.i >= 6)
                return -EINVAL;


@@ -1268,12 +1290,12 @@ static int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);

 
        if (attr->ofs == 1)
 
        if (attr->ofs == 1)

-               return rtl8366_vlan_set_vlan(smi, val->value.i);
+               return rtl8366_vlan_set_vlan(rtl, val->value.i);

        else
        else

-               return rtl8366_vlan_set_4ktable(smi, val->value.i);
+               return rtl8366_vlan_set_4ktable(rtl, val->value.i);

 }
 
 static const char *rtl8366_speed_str(unsigned speed)
 }
 
 static const char *rtl8366_speed_str(unsigned speed)


@@ -1294,20 +1316,21 @@ static int rtl8366_sw_get_port_link(struct switch_dev *dev,
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {
                                    const struct switch_attr *attr,
                                    struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 len = 0, data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS)
                return -EINVAL;
 
        u32 len = 0, data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS)
                return -EINVAL;
 

-       memset(smi->buf, '\0', sizeof(smi->buf));
+       memset(rtl->buf, '\0', sizeof(rtl->buf));

        rtl8366_smi_read_reg(smi, RTL8366S_PORT_LINK_STATUS_BASE +
                             (val->port_vlan / 2), &data);
 
        if (val->port_vlan % 2)
                data = data >> 8;
 
        rtl8366_smi_read_reg(smi, RTL8366S_PORT_LINK_STATUS_BASE +
                             (val->port_vlan / 2), &data);
 
        if (val->port_vlan % 2)
                data = data >> 8;
 

-       len = snprintf(smi->buf, sizeof(smi->buf),
+       len = snprintf(rtl->buf, sizeof(rtl->buf),

                        "port:%d link:%s speed:%s %s-duplex %s%s%s",
                        val->port_vlan,
                        (data & RTL8366S_PORT_STATUS_LINK_MASK) ? "up" : "down",
                        "port:%d link:%s speed:%s %s-duplex %s%s%s",
                        val->port_vlan,
                        (data & RTL8366S_PORT_STATUS_LINK_MASK) ? "up" : "down",


@@ -1321,7 +1344,7 @@ static int rtl8366_sw_get_port_link(struct switch_dev *dev,
                                "rx-pause " : "",
                        (data & RTL8366S_PORT_STATUS_AN_MASK) ? "nway ": "");
 
                                "rx-pause " : "",
                        (data & RTL8366S_PORT_STATUS_AN_MASK) ? "nway ": "");
 

-       val->value.s = smi->buf;
+       val->value.s = rtl->buf;

        val->len = len;
 
        return 0;
        val->len = len;
 
        return 0;


@@ -1335,38 +1358,38 @@ static int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
        u32 len = 0;
        struct rtl8366s_vlanconfig vlanmc;
        struct rtl8366s_vlan4kentry vlan4k;
        u32 len = 0;
        struct rtl8366s_vlanconfig vlanmc;
        struct rtl8366s_vlan4kentry vlan4k;

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
-       char *buf = smi->buf;
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       char *buf = rtl->buf;

 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 
 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 

-       memset(buf, '\0', sizeof(smi->buf));
+       memset(buf, '\0', sizeof(rtl->buf));

 
 

-       rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
-       rtl8366s_get_vlan_4k_entry(smi, vlanmc.vid, &vlan4k);
+       rtl8366s_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);
+       rtl8366s_get_vlan_4k_entry(rtl, vlanmc.vid, &vlan4k);

 
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "VLAN %d: Ports: ",
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "VLAN %d: Ports: ",

                        val->port_vlan);
 
        for (i = 0; i < RTL8366_NUM_PORTS; ++i) {
                int index = 0;
                        val->port_vlan);
 
        for (i = 0; i < RTL8366_NUM_PORTS; ++i) {
                int index = 0;

-               if (!rtl8366_get_port_vlan_index(smi, i, &index) &&
+               if (!rtl8366_get_port_vlan_index(rtl, i, &index) &&

                    index == val->port_vlan)
                    index == val->port_vlan)

-                       len += snprintf(buf + len, sizeof(smi->buf) - len,
+                       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                                        "%d", i);
        }
                                        "%d", i);
        }

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");

 
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "\t\t vid \t prio \t member \t untag \t fid\n");
                        "\t\t vid \t prio \t member \t untag \t fid\n");

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "\tMC:\t");
-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "\tMC:\t");
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "%d \t %d \t 0x%04x \t 0x%04x \t %d\n",
                        vlanmc.vid, vlanmc.priority, vlanmc.member,
                        vlanmc.untag, vlanmc.fid);
                        "%d \t %d \t 0x%04x \t 0x%04x \t %d\n",
                        vlanmc.vid, vlanmc.priority, vlanmc.member,
                        vlanmc.untag, vlanmc.fid);

-       len += snprintf(buf + len, sizeof(smi->buf) - len, "\t4K:\t");
-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len, "\t4K:\t");
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "%d \t  \t 0x%04x \t 0x%04x \t %d",
                        vlan4k.vid, vlan4k.member, vlan4k.untag, vlan4k.fid);
 
                        "%d \t  \t 0x%04x \t 0x%04x \t %d",
                        vlan4k.vid, vlan4k.member, vlan4k.untag, vlan4k.fid);
 


@@ -1380,7 +1403,8 @@ static int rtl8366_sw_set_port_led(struct switch_dev *dev,
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS ||
        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS ||


@@ -1405,7 +1429,8 @@ static int rtl8366_sw_get_port_led(struct switch_dev *dev,
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_LEDGROUPS)
        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_LEDGROUPS)


@@ -1421,7 +1446,8 @@ static int rtl8366_sw_reset_port_mibs(struct switch_dev *dev,
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {
                                      const struct switch_attr *attr,
                                      struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS)
        u32 data = 0;
 
        if (val->port_vlan >= RTL8366_NUM_PORTS)


@@ -1438,26 +1464,26 @@ static int rtl8366_sw_get_port_mib(struct switch_dev *dev,
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {
                                   const struct switch_attr *attr,
                                   struct switch_val *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);

        int i, len = 0;
        unsigned long long counter = 0;
        int i, len = 0;
        unsigned long long counter = 0;

-       char *buf = smi->buf;
+       char *buf = rtl->buf;

 
        if (val->port_vlan >= RTL8366_NUM_PORTS)
                return -EINVAL;
 
 
        if (val->port_vlan >= RTL8366_NUM_PORTS)
                return -EINVAL;
 

-       len += snprintf(buf + len, sizeof(smi->buf) - len,
+       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                        "Port %d MIB counters\n",
                        val->port_vlan);
 
        for (i = 0; i < RTL8366S_MIB_COUNT; ++i) {
                        "Port %d MIB counters\n",
                        val->port_vlan);
 
        for (i = 0; i < RTL8366S_MIB_COUNT; ++i) {

-               len += snprintf(buf + len, sizeof(smi->buf) - len,
+               len += snprintf(buf + len, sizeof(rtl->buf) - len,

                                "%d:%s\t", i, MIBCOUNTERS[i]);
                                "%d:%s\t", i, MIBCOUNTERS[i]);

-               if (!rtl8366_get_mib_counter(smi, i, val->port_vlan, &counter))
-                       len += snprintf(buf + len, sizeof(smi->buf) - len,
+               if (!rtl8366_get_mib_counter(rtl, i, val->port_vlan, &counter))
+                       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                                        "[%llu]\n", counter);
                else
                                        "[%llu]\n", counter);
                else

-                       len += snprintf(buf + len, sizeof(smi->buf) - len,
+                       len += snprintf(buf + len, sizeof(rtl->buf) - len,

                                        "[error]\n");
        }
 
                                        "[error]\n");
        }
 


@@ -1470,14 +1496,14 @@ static int rtl8366_sw_get_vlan_ports(struct switch_dev *dev,
                                     struct switch_val *val)
 {
        struct rtl8366s_vlanconfig vlanmc;
                                     struct switch_val *val)
 {
        struct rtl8366s_vlanconfig vlanmc;

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);

        struct switch_port *port;
        int i;
 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 
        struct switch_port *port;
        int i;
 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 

-       rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
+       rtl8366s_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);

 
        port = &val->value.ports[0];
        val->len = 0;
 
        port = &val->value.ports[0];
        val->len = 0;


@@ -1499,15 +1525,15 @@ static int rtl8366_sw_set_vlan_ports(struct switch_dev *dev,
 {
        struct rtl8366s_vlanconfig vlanmc;
        struct rtl8366s_vlan4kentry vlan4k;
 {
        struct rtl8366s_vlanconfig vlanmc;
        struct rtl8366s_vlan4kentry vlan4k;

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);

        struct switch_port *port;
        int i;
 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 
        struct switch_port *port;
        int i;
 
        if (val->port_vlan >= RTL8366_NUM_VLANS)
                return -EINVAL;
 

-       rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
-       rtl8366s_get_vlan_4k_entry(smi, vlanmc.vid, &vlan4k);
+       rtl8366s_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);
+       rtl8366s_get_vlan_4k_entry(rtl, vlanmc.vid, &vlan4k);

 
        vlanmc.untag = 0;
        vlanmc.member = 0;
 
        vlanmc.untag = 0;
        vlanmc.member = 0;


@@ -1523,26 +1549,27 @@ static int rtl8366_sw_set_vlan_ports(struct switch_dev *dev,
        vlan4k.member = vlanmc.member;
        vlan4k.untag = vlanmc.untag;
 
        vlan4k.member = vlanmc.member;
        vlan4k.untag = vlanmc.untag;
 

-       rtl8366s_set_vlan_member_config(smi, val->port_vlan, &vlanmc);
-       rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
+       rtl8366s_set_vlan_member_config(rtl, val->port_vlan, &vlanmc);
+       rtl8366s_set_vlan_4k_entry(rtl, &vlan4k);

        return 0;
 }
 
 static int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
 {
        return 0;
 }
 
 static int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
-       return rtl8366_get_vlan_port_pvid(smi, port, val);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       return rtl8366_get_vlan_port_pvid(rtl, port, val);

 }
 
 static int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
 {
 }
 
 static int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
-       return rtl8366_set_vlan_port_pvid(smi, port, val);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       return rtl8366_set_vlan_port_pvid(rtl, port, val);

 }
 
 static int rtl8366_sw_reset_switch(struct switch_dev *dev)
 {
 }
 
 static int rtl8366_sw_reset_switch(struct switch_dev *dev)
 {

-       struct rtl8366_smi *smi = sw_to_rtl8366(dev);
+       struct rtl8366s *rtl = sw_to_rtl8366s(dev);
+       struct rtl8366_smi *smi = &rtl->smi;

        int timeout = 10;
        u32 data;
 
        int timeout = 10;
        u32 data;
 


@@ -1562,7 +1589,7 @@ static int rtl8366_sw_reset_switch(struct switch_dev *dev)
                return -EIO;
        }
 
                return -EIO;
        }
 

-       return rtl8366s_reset_vlan(smi);
+       return rtl8366s_reset_vlan(rtl);

 }
 
 static struct switch_attr rtl8366_globals[] = {
 }
 
 static struct switch_attr rtl8366_globals[] = {


@@ -1670,34 +1697,34 @@ static struct switch_dev rtldev = {
        .reset_switch = rtl8366_sw_reset_switch,
 };
 
        .reset_switch = rtl8366_sw_reset_switch,
 };
 

-static int rtl8366_smi_switch_init(struct rtl8366_smi *smi)
+static int rtl8366_smi_switch_init(struct rtl8366s *rtl)

 {
 {

-       struct switch_dev *dev = &smi->dev;
+       struct switch_dev *dev = &rtl->dev;

        int err;
 
        memcpy(dev, &rtldev, sizeof(struct switch_dev));
        int err;
 
        memcpy(dev, &rtldev, sizeof(struct switch_dev));

-       dev->priv = smi;
-       dev->devname = dev_name(smi->parent);
+       dev->priv = rtl;
+       dev->devname = dev_name(rtl->parent);

 
        err = register_switch(dev, NULL);
        if (err)
 
        err = register_switch(dev, NULL);
        if (err)

-               dev_err(smi->parent, "switch registration failed\n");
+               dev_err(rtl->parent, "switch registration failed\n");

 
        return err;
 }
 
 
        return err;
 }
 

-static void rtl8366_smi_switch_cleanup(struct rtl8366_smi *smi)
+static void rtl8366_smi_switch_cleanup(struct rtl8366s *rtl)

 {
 {

-       unregister_switch(&smi->dev);
+       unregister_switch(&rtl->dev);

 }
 
 static int rtl8366_smi_mii_read(struct mii_bus *bus, int addr, int reg)
 {
 }
 
 static int rtl8366_smi_mii_read(struct mii_bus *bus, int addr, int reg)
 {

-       struct rtl8366_smi *smi = bus->priv;
+       struct rtl8366s *rtl = bus->priv;

        u32 val = 0;
        int err;
 
        u32 val = 0;
        int err;
 

-       err = rtl8366_smi_read_phy_reg(smi, addr, 0, reg, &val);
+       err = rtl8366_smi_read_phy_reg(rtl, addr, 0, reg, &val);

        if (err)
                return 0xffff;
 
        if (err)
                return 0xffff;
 


@@ -1707,57 +1734,56 @@ static int rtl8366_smi_mii_read(struct mii_bus *bus, int addr, int reg)
 static int rtl8366_smi_mii_write(struct mii_bus *bus, int addr, int reg,
                                     u16 val)
 {
 static int rtl8366_smi_mii_write(struct mii_bus *bus, int addr, int reg,
                                     u16 val)
 {

-       struct rtl8366_smi *smi = bus->priv;
+       struct rtl8366s *rtl = bus->priv;

        u32 t;
        int err;
 
        u32 t;
        int err;
 

-       err = rtl8366_smi_write_phy_reg(smi, addr, 0, reg, val);
+       err = rtl8366_smi_write_phy_reg(rtl, addr, 0, reg, val);

        /* flush write */
        /* flush write */

-       (void) rtl8366_smi_read_phy_reg(smi, addr, 0, reg, &t);
+       (void) rtl8366_smi_read_phy_reg(rtl, addr, 0, reg, &t);

 
        return err;
 }
 
 
        return err;
 }
 

-static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
+static int rtl8366_smi_mii_init(struct rtl8366s *rtl)

 {
        int ret;
        int i;
 
 {
        int ret;
        int i;
 

-       smi->mii_bus = mdiobus_alloc();
-       if (smi->mii_bus == NULL) {
+       rtl->mii_bus = mdiobus_alloc();
+       if (rtl->mii_bus == NULL) {

                ret = -ENOMEM;
                goto err;
        }
 
                ret = -ENOMEM;
                goto err;
        }
 

-       spin_lock_init(&smi->lock);
-       smi->mii_bus->priv = (void *) smi;
-       smi->mii_bus->name = "rtl8366-smi";
-       smi->mii_bus->read = rtl8366_smi_mii_read;
-       smi->mii_bus->write = rtl8366_smi_mii_write;
-       snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
-                dev_name(smi->parent));
-       smi->mii_bus->parent = smi->parent;
-       smi->mii_bus->phy_mask = ~(0x1f);
-       smi->mii_bus->irq = smi->mii_irq;
+       rtl->mii_bus->priv = (void *) rtl;
+       rtl->mii_bus->name = "rtl8366-rtl";
+       rtl->mii_bus->read = rtl8366_smi_mii_read;
+       rtl->mii_bus->write = rtl8366_smi_mii_write;
+       snprintf(rtl->mii_bus->id, MII_BUS_ID_SIZE, "%s",
+                dev_name(rtl->parent));
+       rtl->mii_bus->parent = rtl->parent;
+       rtl->mii_bus->phy_mask = ~(0x1f);
+       rtl->mii_bus->irq = rtl->mii_irq;

        for (i = 0; i < PHY_MAX_ADDR; i++)
        for (i = 0; i < PHY_MAX_ADDR; i++)

-               smi->mii_irq[i] = PHY_POLL;
+               rtl->mii_irq[i] = PHY_POLL;

 
 

-       ret = mdiobus_register(smi->mii_bus);
+       ret = mdiobus_register(rtl->mii_bus);

        if (ret)
                goto err_free;
 
        return 0;
 
  err_free:
        if (ret)
                goto err_free;
 
        return 0;
 
  err_free:

-       mdiobus_free(smi->mii_bus);
+       mdiobus_free(rtl->mii_bus);

  err:
        return ret;
 }
 
  err:
        return ret;
 }
 

-static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
+static void rtl8366_smi_mii_cleanup(struct rtl8366s *rtl)

 {
 {

-       mdiobus_unregister(smi->mii_bus);
-       mdiobus_free(smi->mii_bus);
+       mdiobus_unregister(rtl->mii_bus);
+       mdiobus_free(rtl->mii_bus);

 }
 
 static int rtl8366_smi_mii_bus_match(struct mii_bus *bus)
 }
 
 static int rtl8366_smi_mii_bus_match(struct mii_bus *bus)


@@ -1766,15 +1792,16 @@ static int rtl8366_smi_mii_bus_match(struct mii_bus *bus)
                bus->write == rtl8366_smi_mii_write);
 }
 
                bus->write == rtl8366_smi_mii_write);
 }
 

-static int rtl8366_smi_setup(struct rtl8366_smi *smi)
+static int rtl8366_smi_setup(struct rtl8366s *rtl)

 {
 {

+       struct rtl8366_smi *smi = &rtl->smi;

        u32 chip_id = 0;
        u32 chip_ver = 0;
        int ret;
 
        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_ID_REG, &chip_id);
        if (ret) {
        u32 chip_id = 0;
        u32 chip_ver = 0;
        int ret;
 
        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_ID_REG, &chip_id);
        if (ret) {

-               dev_err(smi->parent, "unable to read chip id\n");
+               dev_err(rtl->parent, "unable to read chip id\n");

                return ret;
        }
 
                return ret;
        }
 


@@ -1782,21 +1809,21 @@ static int rtl8366_smi_setup(struct rtl8366_smi *smi)
        case RTL8366S_CHIP_ID_8366:
                break;
        default:
        case RTL8366S_CHIP_ID_8366:
                break;
        default:

-               dev_err(smi->parent, "unknown chip id (%04x)\n", chip_id);
+               dev_err(rtl->parent, "unknown chip id (%04x)\n", chip_id);

                return -ENODEV;
        }
 
        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_VERSION_CTRL_REG,
                                   &chip_ver);
        if (ret) {
                return -ENODEV;
        }
 
        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_VERSION_CTRL_REG,
                                   &chip_ver);
        if (ret) {

-               dev_err(smi->parent, "unable to read chip version\n");
+               dev_err(rtl->parent, "unable to read chip version\n");

                return ret;
        }
 
                return ret;
        }
 

-       dev_info(smi->parent, "RTL%04x ver. %u chip found\n",
+       dev_info(rtl->parent, "RTL%04x ver. %u chip found\n",

                 chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK);
 
                 chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK);
 

-       rtl8366_debugfs_init(smi);
+       rtl8366_debugfs_init(rtl);

 
        return 0;
 }
 
        return 0;
 }


@@ -1845,6 +1872,7 @@ static int __init rtl8366_smi_probe(struct platform_device *pdev)
 {
        static int rtl8366_smi_version_printed;
        struct rtl8366_smi_platform_data *pdata;
 {
        static int rtl8366_smi_version_printed;
        struct rtl8366_smi_platform_data *pdata;

+       struct rtl8366s *rtl;

        struct rtl8366_smi *smi;
        int err;
 
        struct rtl8366_smi *smi;
        int err;
 


@@ -1859,43 +1887,47 @@ static int __init rtl8366_smi_probe(struct platform_device *pdev)
                goto err_out;
        }
 
                goto err_out;
        }
 

-       smi = kzalloc(sizeof(struct rtl8366_smi), GFP_KERNEL);
-       if (!smi) {
+       rtl = kzalloc(sizeof(*rtl), GFP_KERNEL);
+       if (!rtl) {

                dev_err(&pdev->dev, "no memory for private data\n");
                err = -ENOMEM;
                goto err_out;
        }
 
                dev_err(&pdev->dev, "no memory for private data\n");
                err = -ENOMEM;
                goto err_out;
        }
 

+       rtl->parent = &pdev->dev;
+
+       smi = &rtl->smi;

        smi->parent = &pdev->dev;
        smi->gpio_sda = pdata->gpio_sda;
        smi->gpio_sck = pdata->gpio_sck;
 
        err = rtl8366_smi_init(smi);
        if (err)
        smi->parent = &pdev->dev;
        smi->gpio_sda = pdata->gpio_sda;
        smi->gpio_sck = pdata->gpio_sck;
 
        err = rtl8366_smi_init(smi);
        if (err)

-               goto err_free_smi;
+               goto err_free_rtl;

 
 

-       platform_set_drvdata(pdev, smi);
+       platform_set_drvdata(pdev, rtl);

 
 

-       err = rtl8366_smi_setup(smi);
+       err = rtl8366_smi_setup(rtl);

        if (err)
                goto err_clear_drvdata;
 
        if (err)
                goto err_clear_drvdata;
 

-       err = rtl8366_smi_mii_init(smi);
+       err = rtl8366_smi_mii_init(rtl);

        if (err)
                goto err_clear_drvdata;
 
        if (err)
                goto err_clear_drvdata;
 

-       err = rtl8366_smi_switch_init(smi);
+       err = rtl8366_smi_switch_init(rtl);

        if (err)
                goto err_mii_cleanup;
 
        return 0;
 
  err_mii_cleanup:
        if (err)
                goto err_mii_cleanup;
 
        return 0;
 
  err_mii_cleanup:

-       rtl8366_smi_mii_cleanup(smi);
+       rtl8366_smi_mii_cleanup(rtl);

  err_clear_drvdata:
        platform_set_drvdata(pdev, NULL);
  err_clear_drvdata:
        platform_set_drvdata(pdev, NULL);

- err_free_smi:
-       kfree(smi);
+       rtl8366_smi_cleanup(smi);
+ err_free_rtl:
+       kfree(rtl);

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


@@ -1928,15 +1960,15 @@ static struct phy_driver rtl8366_smi_phy_driver = {
 
 static int __devexit rtl8366_smi_remove(struct platform_device *pdev)
 {
 
 static int __devexit rtl8366_smi_remove(struct platform_device *pdev)
 {

-       struct rtl8366_smi *smi = platform_get_drvdata(pdev);
+       struct rtl8366s *rtl = platform_get_drvdata(pdev);

 
 

-       if (smi) {
-               rtl8366_smi_switch_cleanup(smi);
-               rtl8366_debugfs_remove(smi);
-               rtl8366_smi_mii_cleanup(smi);
+       if (rtl) {
+               rtl8366_smi_switch_cleanup(rtl);
+               rtl8366_debugfs_remove(rtl);
+               rtl8366_smi_mii_cleanup(rtl);

                platform_set_drvdata(pdev, NULL);
                platform_set_drvdata(pdev, NULL);

-               rtl8366_smi_cleanup(smi);
-               kfree(smi);
+               rtl8366_smi_cleanup(&rtl->smi);
+               kfree(rtl);

        }
 
        return 0;
        }
 
        return 0;