Changeset 19278


Ignore:
Timestamp:
2010-01-22T18:37:58+01:00 (7 years ago)
Author:
juhosg
Message:

rtl8366_smi: rename rtl8366s specific functions and definitions

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/net/phy/rtl8366_smi.c

    r19277 r19278  
    2626#endif 
    2727 
    28 #define RTL8366_SMI_DRIVER_NAME "rtl8366-smi" 
    29 #define RTL8366_SMI_DRIVER_DESC "Realtek RTL8366 switch driver" 
    30 #define RTL8366_SMI_DRIVER_VER  "0.1.1" 
     28#define RTL8366S_DRIVER_NAME    "rtl8366-smi" 
     29#define RTL8366S_DRIVER_DESC    "Realtek RTL8366 switch driver" 
     30#define RTL8366S_DRIVER_VER     "0.1.1" 
    3131 
    3232#define RTL8366S_PHY_NO_MAX                 4 
     
    483483} 
    484484 
    485 static int rtl8366_smi_read_phy_reg(struct rtl8366s *rtl, 
    486                                     u32 phy_no, u32 page, u32 addr, u32 *data) 
     485static int rtl8366s_read_phy_reg(struct rtl8366s *rtl, 
     486                                 u32 phy_no, u32 page, u32 addr, u32 *data) 
    487487{ 
    488488        struct rtl8366_smi *smi = &rtl->smi; 
     
    519519} 
    520520 
    521 static int rtl8366_smi_write_phy_reg(struct rtl8366s *rtl, 
    522                                      u32 phy_no, u32 page, u32 addr, u32 data) 
     521static int rtl8366s_write_phy_reg(struct rtl8366s *rtl, 
     522                                  u32 phy_no, u32 page, u32 addr, u32 data) 
    523523{ 
    524524        struct rtl8366_smi *smi = &rtl->smi; 
     
    772772} 
    773773 
    774 static int rtl8366_get_port_vlan_index(struct rtl8366s *rtl, int port, 
     774static int rtl8366s_get_port_vlan_index(struct rtl8366s *rtl, int port, 
    775775                                       int *val) 
    776776{ 
     
    794794} 
    795795 
    796 static int rtl8366_get_vlan_port_pvid(struct rtl8366s *rtl, int port, 
    797                                       int *val) 
     796static int rtl8366s_get_vlan_port_pvid(struct rtl8366s *rtl, int port, 
     797                                       int *val) 
    798798{ 
    799799        struct rtl8366s_vlanconfig vlanmc; 
     
    801801        int index; 
    802802 
    803         err = rtl8366_get_port_vlan_index(rtl, port, &index); 
     803        err = rtl8366s_get_port_vlan_index(rtl, port, &index); 
    804804        if (err) 
    805805                return err; 
     
    813813} 
    814814 
    815 static int rtl8366_set_port_vlan_index(struct rtl8366s *rtl, int port, 
    816                                        int index) 
     815static int rtl8366s_set_port_vlan_index(struct rtl8366s *rtl, int port, 
     816                                        int index) 
    817817{ 
    818818        struct rtl8366_smi *smi = &rtl->smi; 
     
    838838} 
    839839 
    840 static int rtl8366_set_vlan_port_pvid(struct rtl8366s *rtl, int port, 
    841                                       int val) 
     840static int rtl8366s_set_vlan_port_pvid(struct rtl8366s *rtl, int port, int val) 
    842841{ 
    843842        int i; 
     
    867866 
    868867                        /* Now update PVID register settings */ 
    869                         rtl8366_set_port_vlan_index(rtl, port, i); 
     868                        rtl8366s_set_port_vlan_index(rtl, port, i); 
    870869 
    871870                        return 0; 
     
    894893 
    895894                        /* Now update PVID register settings */ 
    896                         rtl8366_set_port_vlan_index(rtl, port, i); 
     895                        rtl8366s_set_port_vlan_index(rtl, port, i); 
    897896 
    898897                        return 0; 
     
    907906 
    908907 
    909 static int rtl8366_vlan_set_vlan(struct rtl8366s *rtl, int enable) 
     908static int rtl8366s_vlan_set_vlan(struct rtl8366s *rtl, int enable) 
    910909{ 
    911910        struct rtl8366_smi *smi = &rtl->smi; 
     
    922921} 
    923922 
    924 static int rtl8366_vlan_set_4ktable(struct rtl8366s *rtl, int enable) 
     923static int rtl8366s_vlan_set_4ktable(struct rtl8366s *rtl, int enable) 
    925924{ 
    926925        struct rtl8366_smi *smi = &rtl->smi; 
     
    967966        /* Set all ports PVID to default VLAN */ 
    968967        for (i = 0; i < RTL8366_NUM_PORTS; i++) { 
    969                 err = rtl8366_set_vlan_port_pvid(rtl, i, 0); 
     968                err = rtl8366s_set_vlan_port_pvid(rtl, i, 0); 
    970969                if (err) 
    971970                        return err; 
     
    976975 
    977976#ifdef CONFIG_RTL8366_SMI_DEBUG_FS 
    978 static int rtl8366_debugfs_open(struct inode *inode, struct file *file) 
     977static int rtl8366s_debugfs_open(struct inode *inode, struct file *file) 
    979978{ 
    980979        file->private_data = inode->i_private; 
     
    982981} 
    983982 
    984 static ssize_t rtl8366_read_debugfs_mibs(struct file *file, 
    985                                          char __user *user_buf, 
    986                                          size_t count, loff_t *ppos) 
     983static ssize_t rtl8366s_read_debugfs_mibs(struct file *file, 
     984                                          char __user *user_buf, 
     985                                          size_t count, loff_t *ppos) 
    987986{ 
    988987        struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
     
    10301029} 
    10311030 
    1032 static ssize_t rtl8366_read_debugfs_vlan(struct file *file, 
    1033                                          char __user *user_buf, 
    1034                                          size_t count, loff_t *ppos) 
     1031static ssize_t rtl8366s_read_debugfs_vlan(struct file *file, 
     1032                                          char __user *user_buf, 
     1033                                          size_t count, loff_t *ppos) 
    10351034{ 
    10361035        struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
     
    10561055                for (j = 0; j < RTL8366_NUM_PORTS; ++j) { 
    10571056                        int index = 0; 
    1058                         if (!rtl8366_get_port_vlan_index(rtl, j, &index)) { 
     1057                        if (!rtl8366s_get_port_vlan_index(rtl, j, &index)) { 
    10591058                                if (index == i) 
    10601059                                        len += snprintf(buf + len, 
     
    10691068} 
    10701069 
    1071 static ssize_t rtl8366_read_debugfs_reg(struct file *file, 
    1072                                         char __user *user_buf, 
    1073                                         size_t count, loff_t *ppos) 
     1070static ssize_t rtl8366s_read_debugfs_reg(struct file *file, 
     1071                                         char __user *user_buf, 
     1072                                         size_t count, loff_t *ppos) 
    10741073{ 
    10751074        struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
     
    10941093} 
    10951094 
    1096 static ssize_t rtl8366_write_debugfs_reg(struct file *file, 
    1097                                          const char __user *user_buf, 
    1098                                          size_t count, loff_t *ppos) 
     1095static ssize_t rtl8366s_write_debugfs_reg(struct file *file, 
     1096                                          const char __user *user_buf, 
     1097                                          size_t count, loff_t *ppos) 
    10991098{ 
    11001099        struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
     
    11311130} 
    11321131 
    1133 static const struct file_operations fops_rtl8366_regs = { 
    1134         .read = rtl8366_read_debugfs_reg, 
    1135         .write = rtl8366_write_debugfs_reg, 
    1136         .open = rtl8366_debugfs_open, 
     1132static const struct file_operations fops_rtl8366s_regs = { 
     1133        .read = rtl8366s_read_debugfs_reg, 
     1134        .write = rtl8366s_write_debugfs_reg, 
     1135        .open = rtl8366s_debugfs_open, 
    11371136        .owner = THIS_MODULE 
    11381137}; 
    11391138 
    1140 static const struct file_operations fops_rtl8366_vlan = { 
    1141         .read = rtl8366_read_debugfs_vlan, 
    1142         .open = rtl8366_debugfs_open, 
     1139static const struct file_operations fops_rtl8366s_vlan = { 
     1140        .read = rtl8366s_read_debugfs_vlan, 
     1141        .open = rtl8366s_debugfs_open, 
    11431142        .owner = THIS_MODULE 
    11441143}; 
    11451144 
    1146 static const struct file_operations fops_rtl8366_mibs = { 
    1147         .read = rtl8366_read_debugfs_mibs, 
    1148         .open = rtl8366_debugfs_open, 
     1145static const struct file_operations fops_rtl8366s_mibs = { 
     1146        .read = rtl8366s_read_debugfs_mibs, 
     1147        .open = rtl8366s_debugfs_open, 
    11491148        .owner = THIS_MODULE 
    11501149}; 
    11511150 
    1152 static void rtl8366_debugfs_init(struct rtl8366s *rtl) 
     1151static void rtl8366s_debugfs_init(struct rtl8366s *rtl) 
    11531152{ 
    11541153        struct dentry *node; 
     
    11711170 
    11721171        node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, rtl, 
    1173                                    &fops_rtl8366_regs); 
     1172                                   &fops_rtl8366s_regs); 
    11741173        if (!node) { 
    11751174                dev_err(rtl->parent, "Creating debugfs file val failed\n"); 
     
    11781177 
    11791178        node = debugfs_create_file("vlan", S_IRUSR, root, rtl, 
    1180                                    &fops_rtl8366_vlan); 
     1179                                   &fops_rtl8366s_vlan); 
    11811180        if (!node) { 
    11821181                dev_err(rtl->parent, 
     
    11861185 
    11871186        node = debugfs_create_file("mibs", S_IRUSR, root, rtl, 
    1188                                    &fops_rtl8366_mibs); 
     1187                                   &fops_rtl8366s_mibs); 
    11891188        if (!node) { 
    11901189                dev_err(rtl->parent, 
     
    11941193} 
    11951194 
    1196 static void rtl8366_debugfs_remove(struct rtl8366s *rtl) 
     1195static void rtl8366s_debugfs_remove(struct rtl8366s *rtl) 
    11971196{ 
    11981197        if (rtl->debugfs_root) { 
     
    12031202 
    12041203#else 
    1205 static inline void rtl8366_debugfs_init(struct rtl8366s *rtl) {} 
    1206 static inline void rtl8366_debugfs_remove(struct rtl8366s *rtl) {} 
     1204static inline void rtl8366s_debugfs_init(struct rtl8366s *rtl) {} 
     1205static inline void rtl8366s_debugfs_remove(struct rtl8366s *rtl) {} 
    12071206#endif /* CONFIG_RTL8366_SMI_DEBUG_FS */ 
    12081207 
    1209 static int rtl8366_sw_reset_mibs(struct switch_dev *dev, 
    1210                                  const struct switch_attr *attr, 
    1211                                  struct switch_val *val) 
     1208static int rtl8366s_sw_reset_mibs(struct switch_dev *dev, 
     1209                                  const struct switch_attr *attr, 
     1210                                  struct switch_val *val) 
    12121211{ 
    12131212        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    12241223} 
    12251224 
    1226 static int rtl8366_sw_get_vlan_enable(struct switch_dev *dev, 
    1227                                       const struct switch_attr *attr, 
    1228                                       struct switch_val *val) 
     1225static int rtl8366s_sw_get_vlan_enable(struct switch_dev *dev, 
     1226                                       const struct switch_attr *attr, 
     1227                                       struct switch_val *val) 
    12291228{ 
    12301229        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    12511250} 
    12521251 
    1253 static int rtl8366_sw_get_blinkrate(struct switch_dev *dev, 
     1252static int rtl8366s_sw_get_blinkrate(struct switch_dev *dev, 
     1253                                     const struct switch_attr *attr, 
     1254                                     struct switch_val *val) 
     1255{ 
     1256        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     1257        struct rtl8366_smi *smi = &rtl->smi; 
     1258        u32 data; 
     1259 
     1260        rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data); 
     1261 
     1262        val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK)); 
     1263 
     1264        return 0; 
     1265} 
     1266 
     1267static int rtl8366s_sw_set_blinkrate(struct switch_dev *dev, 
    12541268                                    const struct switch_attr *attr, 
    12551269                                    struct switch_val *val) 
     
    12591273        u32 data; 
    12601274 
    1261         rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data); 
    1262  
    1263         val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK)); 
    1264  
    1265         return 0; 
    1266 } 
    1267  
    1268 static int rtl8366_sw_set_blinkrate(struct switch_dev *dev, 
    1269                                     const struct switch_attr *attr, 
    1270                                     struct switch_val *val) 
    1271 { 
    1272         struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
    1273         struct rtl8366_smi *smi = &rtl->smi; 
    1274         u32 data; 
    1275  
    12761275        if (val->value.i >= 6) 
    12771276                return -EINVAL; 
     
    12871286} 
    12881287 
    1289 static int rtl8366_sw_set_vlan_enable(struct switch_dev *dev, 
    1290                                       const struct switch_attr *attr, 
    1291                                       struct switch_val *val) 
     1288static int rtl8366s_sw_set_vlan_enable(struct switch_dev *dev, 
     1289                                       const struct switch_attr *attr, 
     1290                                       struct switch_val *val) 
    12921291{ 
    12931292        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
    12941293 
    12951294        if (attr->ofs == 1) 
    1296                 return rtl8366_vlan_set_vlan(rtl, val->value.i); 
     1295                return rtl8366s_vlan_set_vlan(rtl, val->value.i); 
    12971296        else 
    1298                 return rtl8366_vlan_set_4ktable(rtl, val->value.i); 
    1299 } 
    1300  
    1301 static const char *rtl8366_speed_str(unsigned speed) 
     1297                return rtl8366s_vlan_set_4ktable(rtl, val->value.i); 
     1298} 
     1299 
     1300static const char *rtl8366s_speed_str(unsigned speed) 
    13021301{ 
    13031302        switch (speed) { 
     
    13131312} 
    13141313 
    1315 static int rtl8366_sw_get_port_link(struct switch_dev *dev, 
    1316                                     const struct switch_attr *attr, 
    1317                                     struct switch_val *val) 
     1314static int rtl8366s_sw_get_port_link(struct switch_dev *dev, 
     1315                                     const struct switch_attr *attr, 
     1316                                     struct switch_val *val) 
    13181317{ 
    13191318        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    13351334                        val->port_vlan, 
    13361335                        (data & RTL8366S_PORT_STATUS_LINK_MASK) ? "up" : "down", 
    1337                         rtl8366_speed_str(data & 
     1336                        rtl8366s_speed_str(data & 
    13381337                                          RTL8366S_PORT_STATUS_SPEED_MASK), 
    13391338                        (data & RTL8366S_PORT_STATUS_DUPLEX_MASK) ? 
     
    13511350} 
    13521351 
    1353 static int rtl8366_sw_get_vlan_info(struct switch_dev *dev, 
    1354                                     const struct switch_attr *attr, 
    1355                                     struct switch_val *val) 
     1352static int rtl8366s_sw_get_vlan_info(struct switch_dev *dev, 
     1353                                     const struct switch_attr *attr, 
     1354                                     struct switch_val *val) 
    13561355{ 
    13571356        int i; 
     
    13751374        for (i = 0; i < RTL8366_NUM_PORTS; ++i) { 
    13761375                int index = 0; 
    1377                 if (!rtl8366_get_port_vlan_index(rtl, i, &index) && 
     1376                if (!rtl8366s_get_port_vlan_index(rtl, i, &index) && 
    13781377                    index == val->port_vlan) 
    13791378                        len += snprintf(buf + len, sizeof(rtl->buf) - len, 
     
    14001399} 
    14011400 
    1402 static int rtl8366_sw_set_port_led(struct switch_dev *dev, 
    1403                                    const struct switch_attr *attr, 
    1404                                    struct switch_val *val) 
     1401static int rtl8366s_sw_set_port_led(struct switch_dev *dev, 
     1402                                    const struct switch_attr *attr, 
     1403                                    struct switch_val *val) 
    14051404{ 
    14061405        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    14261425} 
    14271426 
    1428 static int rtl8366_sw_get_port_led(struct switch_dev *dev, 
    1429                                    const struct switch_attr *attr, 
    1430                                    struct switch_val *val) 
     1427static int rtl8366s_sw_get_port_led(struct switch_dev *dev, 
     1428                                    const struct switch_attr *attr, 
     1429                                    struct switch_val *val) 
    14311430{ 
    14321431        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    14431442} 
    14441443 
    1445 static int rtl8366_sw_reset_port_mibs(struct switch_dev *dev, 
    1446                                       const struct switch_attr *attr, 
    1447                                       struct switch_val *val) 
     1444static int rtl8366s_sw_reset_port_mibs(struct switch_dev *dev, 
     1445                                       const struct switch_attr *attr, 
     1446                                       struct switch_val *val) 
    14481447{ 
    14491448        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    14611460} 
    14621461 
    1463 static int rtl8366_sw_get_port_mib(struct switch_dev *dev, 
    1464                                    const struct switch_attr *attr, 
    1465                                    struct switch_val *val) 
     1462static int rtl8366s_sw_get_port_mib(struct switch_dev *dev, 
     1463                                    const struct switch_attr *attr, 
     1464                                    struct switch_val *val) 
    14661465{ 
    14671466        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    14931492} 
    14941493 
    1495 static int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, 
    1496                                      struct switch_val *val) 
     1494static int rtl8366s_sw_get_vlan_ports(struct switch_dev *dev, 
     1495                                      struct switch_val *val) 
    14971496{ 
    14981497        struct rtl8366s_vlanconfig vlanmc; 
     
    15211520} 
    15221521 
    1523 static int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, 
    1524                                      struct switch_val *val) 
     1522static int rtl8366s_sw_set_vlan_ports(struct switch_dev *dev, 
     1523                                      struct switch_val *val) 
    15251524{ 
    15261525        struct rtl8366s_vlanconfig vlanmc; 
     
    15551554} 
    15561555 
    1557 static int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val) 
     1556static int rtl8366s_sw_get_port_pvid(struct switch_dev *dev, int port, int *val) 
    15581557{ 
    15591558        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
    1560         return rtl8366_get_vlan_port_pvid(rtl, port, val); 
    1561 } 
    1562  
    1563 static int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val) 
     1559        return rtl8366s_get_vlan_port_pvid(rtl, port, val); 
     1560} 
     1561 
     1562static int rtl8366s_sw_set_port_pvid(struct switch_dev *dev, int port, int val) 
    15641563{ 
    15651564        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
    1566         return rtl8366_set_vlan_port_pvid(rtl, port, val); 
    1567 } 
    1568  
    1569 static int rtl8366_sw_reset_switch(struct switch_dev *dev) 
     1565        return rtl8366s_set_vlan_port_pvid(rtl, port, val); 
     1566} 
     1567 
     1568static int rtl8366s_sw_reset_switch(struct switch_dev *dev) 
    15701569{ 
    15711570        struct rtl8366s *rtl = sw_to_rtl8366s(dev); 
     
    15931592} 
    15941593 
    1595 static struct switch_attr rtl8366_globals[] = { 
     1594static struct switch_attr rtl8366s_globals[] = { 
    15961595        { 
    15971596                .type = SWITCH_TYPE_INT, 
    15981597                .name = "enable_vlan", 
    15991598                .description = "Enable VLAN mode", 
    1600                 .set = rtl8366_sw_set_vlan_enable, 
    1601                 .get = rtl8366_sw_get_vlan_enable, 
     1599                .set = rtl8366s_sw_set_vlan_enable, 
     1600                .get = rtl8366s_sw_get_vlan_enable, 
    16021601                .max = 1, 
    16031602                .ofs = 1 
     
    16061605                .name = "enable_vlan4k", 
    16071606                .description = "Enable VLAN 4K mode", 
    1608                 .set = rtl8366_sw_set_vlan_enable, 
    1609                 .get = rtl8366_sw_get_vlan_enable, 
     1607                .set = rtl8366s_sw_set_vlan_enable, 
     1608                .get = rtl8366s_sw_get_vlan_enable, 
    16101609                .max = 1, 
    16111610                .ofs = 2 
     
    16141613                .name = "reset_mibs", 
    16151614                .description = "Reset all MIB counters", 
    1616                 .set = rtl8366_sw_reset_mibs, 
     1615                .set = rtl8366s_sw_reset_mibs, 
    16171616                .get = NULL, 
    16181617                .max = 1 
     
    16221621                .description = "Get/Set LED blinking rate (0 = 43ms, 1 = 84ms," 
    16231622                " 2 = 120ms, 3 = 170ms, 4 = 340ms, 5 = 670ms)", 
    1624                 .set = rtl8366_sw_set_blinkrate, 
    1625                 .get = rtl8366_sw_get_blinkrate, 
     1623                .set = rtl8366s_sw_set_blinkrate, 
     1624                .get = rtl8366s_sw_get_blinkrate, 
    16261625                .max = 5 
    16271626        }, 
    16281627}; 
    16291628 
    1630 static struct switch_attr rtl8366_port[] = { 
     1629static struct switch_attr rtl8366s_port[] = { 
    16311630        { 
    16321631                .type = SWITCH_TYPE_STRING, 
     
    16351634                .max = 1, 
    16361635                .set = NULL, 
    1637                 .get = rtl8366_sw_get_port_link, 
     1636                .get = rtl8366s_sw_get_port_link, 
    16381637        }, { 
    16391638                .type = SWITCH_TYPE_INT, 
     
    16411640                .description = "Reset single port MIB counters", 
    16421641                .max = 1, 
    1643                 .set = rtl8366_sw_reset_port_mibs, 
     1642                .set = rtl8366s_sw_reset_port_mibs, 
    16441643                .get = NULL, 
    16451644        }, { 
     
    16491648                .max = 33, 
    16501649                .set = NULL, 
    1651                 .get = rtl8366_sw_get_port_mib, 
     1650                .get = rtl8366s_sw_get_port_mib, 
    16521651        }, { 
    16531652                .type = SWITCH_TYPE_INT, 
     
    16551654                .description = "Get/Set port group (0 - 3) led mode (0 - 15)", 
    16561655                .max = 15, 
    1657                 .set = rtl8366_sw_set_port_led, 
    1658                 .get = rtl8366_sw_get_port_led, 
     1656                .set = rtl8366s_sw_set_port_led, 
     1657                .get = rtl8366s_sw_get_port_led, 
    16591658        }, 
    16601659}; 
    16611660 
    1662 static struct switch_attr rtl8366_vlan[] = { 
     1661static struct switch_attr rtl8366s_vlan[] = { 
    16631662        { 
    16641663                .type = SWITCH_TYPE_STRING, 
     
    16671666                .max = 1, 
    16681667                .set = NULL, 
    1669                 .get = rtl8366_sw_get_vlan_info, 
     1668                .get = rtl8366s_sw_get_vlan_info, 
    16701669        }, 
    16711670}; 
     
    16731672 
    16741673/* template */ 
    1675 static struct switch_dev rtldev = { 
     1674static struct switch_dev rtl8366_switch_dev = { 
    16761675        .name = "RTL8366S", 
    16771676        .cpu_port = RTL8366_PORT_NUM_CPU, 
     
    16791678        .vlans = RTL8366_NUM_VLANS, 
    16801679        .attr_global = { 
    1681                 .attr = rtl8366_globals, 
    1682                 .n_attr = ARRAY_SIZE(rtl8366_globals), 
     1680                .attr = rtl8366s_globals, 
     1681                .n_attr = ARRAY_SIZE(rtl8366s_globals), 
    16831682        }, 
    16841683        .attr_port = { 
    1685                 .attr = rtl8366_port, 
    1686                 .n_attr = ARRAY_SIZE(rtl8366_port), 
     1684                .attr = rtl8366s_port, 
     1685                .n_attr = ARRAY_SIZE(rtl8366s_port), 
    16871686        }, 
    16881687        .attr_vlan = { 
    1689                 .attr = rtl8366_vlan, 
    1690                 .n_attr = ARRAY_SIZE(rtl8366_vlan), 
     1688                .attr = rtl8366s_vlan, 
     1689                .n_attr = ARRAY_SIZE(rtl8366s_vlan), 
    16911690        }, 
    16921691 
    1693         .get_vlan_ports = rtl8366_sw_get_vlan_ports, 
    1694         .set_vlan_ports = rtl8366_sw_set_vlan_ports, 
    1695         .get_port_pvid = rtl8366_sw_get_port_pvid, 
    1696         .set_port_pvid = rtl8366_sw_set_port_pvid, 
    1697         .reset_switch = rtl8366_sw_reset_switch, 
     1692        .get_vlan_ports = rtl8366s_sw_get_vlan_ports, 
     1693        .set_vlan_ports = rtl8366s_sw_set_vlan_ports, 
     1694        .get_port_pvid = rtl8366s_sw_get_port_pvid, 
     1695        .set_port_pvid = rtl8366s_sw_set_port_pvid, 
     1696        .reset_switch = rtl8366s_sw_reset_switch, 
    16981697}; 
    16991698 
    1700 static int rtl8366_smi_switch_init(struct rtl8366s *rtl) 
     1699static int rtl8366s_switch_init(struct rtl8366s *rtl) 
    17011700{ 
    17021701        struct switch_dev *dev = &rtl->dev; 
    17031702        int err; 
    17041703 
    1705         memcpy(dev, &rtldev, sizeof(struct switch_dev)); 
     1704        memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev)); 
    17061705        dev->priv = rtl; 
    17071706        dev->devname = dev_name(rtl->parent); 
     
    17141713} 
    17151714 
    1716 static void rtl8366_smi_switch_cleanup(struct rtl8366s *rtl) 
     1715static void rtl8366s_switch_cleanup(struct rtl8366s *rtl) 
    17171716{ 
    17181717        unregister_switch(&rtl->dev); 
    17191718} 
    17201719 
    1721 static int rtl8366_smi_mii_read(struct mii_bus *bus, int addr, int reg) 
     1720static int rtl8366s_mii_read(struct mii_bus *bus, int addr, int reg) 
    17221721{ 
    17231722        struct rtl8366s *rtl = bus->priv; 
     
    17251724        int err; 
    17261725 
    1727         err = rtl8366_smi_read_phy_reg(rtl, addr, 0, reg, &val); 
     1726        err = rtl8366s_read_phy_reg(rtl, addr, 0, reg, &val); 
    17281727        if (err) 
    17291728                return 0xffff; 
     
    17321731} 
    17331732 
    1734 static int rtl8366_smi_mii_write(struct mii_bus *bus, int addr, int reg, 
    1735                                      u16 val) 
     1733static int rtl8366s_mii_write(struct mii_bus *bus, int addr, int reg, u16 val) 
    17361734{ 
    17371735        struct rtl8366s *rtl = bus->priv; 
     
    17391737        int err; 
    17401738 
    1741         err = rtl8366_smi_write_phy_reg(rtl, addr, 0, reg, val); 
     1739        err = rtl8366s_write_phy_reg(rtl, addr, 0, reg, val); 
    17421740        /* flush write */ 
    1743         (void) rtl8366_smi_read_phy_reg(rtl, addr, 0, reg, &t); 
     1741        (void) rtl8366s_read_phy_reg(rtl, addr, 0, reg, &t); 
    17441742 
    17451743        return err; 
    17461744} 
    17471745 
    1748 static int rtl8366_smi_mii_init(struct rtl8366s *rtl) 
     1746static int rtl8366s_mii_init(struct rtl8366s *rtl) 
    17491747{ 
    17501748        int ret; 
     
    17591757        rtl->mii_bus->priv = (void *) rtl; 
    17601758        rtl->mii_bus->name = "rtl8366-rtl"; 
    1761         rtl->mii_bus->read = rtl8366_smi_mii_read; 
    1762         rtl->mii_bus->write = rtl8366_smi_mii_write; 
     1759        rtl->mii_bus->read = rtl8366s_mii_read; 
     1760        rtl->mii_bus->write = rtl8366s_mii_write; 
    17631761        snprintf(rtl->mii_bus->id, MII_BUS_ID_SIZE, "%s", 
    17641762                 dev_name(rtl->parent)); 
     
    17811779} 
    17821780 
    1783 static void rtl8366_smi_mii_cleanup(struct rtl8366s *rtl) 
     1781static void rtl8366s_mii_cleanup(struct rtl8366s *rtl) 
    17841782{ 
    17851783        mdiobus_unregister(rtl->mii_bus); 
     
    17871785} 
    17881786 
    1789 static int rtl8366_smi_mii_bus_match(struct mii_bus *bus) 
    1790 { 
    1791         return (bus->read == rtl8366_smi_mii_read && 
    1792                 bus->write == rtl8366_smi_mii_write); 
    1793 } 
    1794  
    1795 static int rtl8366_smi_setup(struct rtl8366s *rtl) 
     1787static int rtl8366s_mii_bus_match(struct mii_bus *bus) 
     1788{ 
     1789        return (bus->read == rtl8366s_mii_read && 
     1790                bus->write == rtl8366s_mii_write); 
     1791} 
     1792 
     1793static int rtl8366s_setup(struct rtl8366s *rtl) 
    17961794{ 
    17971795        struct rtl8366_smi *smi = &rtl->smi; 
     
    18241822                 chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK); 
    18251823 
    1826         rtl8366_debugfs_init(rtl); 
     1824        rtl8366s_debugfs_init(rtl); 
    18271825 
    18281826        return 0; 
     
    18691867} 
    18701868 
    1871 static int __init rtl8366_smi_probe(struct platform_device *pdev) 
     1869static int __init rtl8366s_probe(struct platform_device *pdev) 
    18721870{ 
    18731871        static int rtl8366_smi_version_printed; 
     
    18781876 
    18791877        if (!rtl8366_smi_version_printed++) 
    1880                 printk(KERN_NOTICE RTL8366_SMI_DRIVER_DESC 
    1881                        " version " RTL8366_SMI_DRIVER_VER"\n"); 
     1878                printk(KERN_NOTICE RTL8366S_DRIVER_DESC 
     1879                       " version " RTL8366S_DRIVER_VER"\n"); 
    18821880 
    18831881        pdata = pdev->dev.platform_data; 
     
    19081906        platform_set_drvdata(pdev, rtl); 
    19091907 
    1910         err = rtl8366_smi_setup(rtl); 
     1908        err = rtl8366s_setup(rtl); 
    19111909        if (err) 
    19121910                goto err_clear_drvdata; 
    19131911 
    1914         err = rtl8366_smi_mii_init(rtl); 
     1912        err = rtl8366s_mii_init(rtl); 
    19151913        if (err) 
    19161914                goto err_clear_drvdata; 
    19171915 
    1918         err = rtl8366_smi_switch_init(rtl); 
     1916        err = rtl8366s_switch_init(rtl); 
    19191917        if (err) 
    19201918                goto err_mii_cleanup; 
     
    19231921 
    19241922 err_mii_cleanup: 
    1925         rtl8366_smi_mii_cleanup(rtl); 
     1923        rtl8366s_mii_cleanup(rtl); 
    19261924 err_clear_drvdata: 
    19271925        platform_set_drvdata(pdev, NULL); 
     
    19331931} 
    19341932 
    1935 static int rtl8366_phy_config_init(struct phy_device *phydev) 
    1936 { 
    1937         if (!rtl8366_smi_mii_bus_match(phydev->bus)) 
    1938                 return -EINVAL; 
    1939  
    1940         return 0; 
    1941 } 
    1942  
    1943 static int rtl8366_phy_config_aneg(struct phy_device *phydev) 
    1944 { 
    1945         return 0; 
    1946 } 
    1947  
    1948 static struct phy_driver rtl8366_smi_phy_driver = { 
     1933static int rtl8366s_phy_config_init(struct phy_device *phydev) 
     1934{ 
     1935        if (!rtl8366s_mii_bus_match(phydev->bus)) 
     1936                return -EINVAL; 
     1937 
     1938        return 0; 
     1939} 
     1940 
     1941static int rtl8366s_phy_config_aneg(struct phy_device *phydev) 
     1942{ 
     1943        return 0; 
     1944} 
     1945 
     1946static struct phy_driver rtl8366s_phy_driver = { 
    19491947        .phy_id         = 0x001cc960, 
    19501948        .name           = "Realtek RTL8366", 
    19511949        .phy_id_mask    = 0x1ffffff0, 
    19521950        .features       = PHY_GBIT_FEATURES, 
    1953         .config_aneg    = rtl8366_phy_config_aneg, 
    1954         .config_init    = rtl8366_phy_config_init, 
     1951        .config_aneg    = rtl8366s_phy_config_aneg, 
     1952        .config_init    = rtl8366s_phy_config_init, 
    19551953        .read_status    = genphy_read_status, 
    19561954        .driver         = { 
     
    19591957}; 
    19601958 
    1961 static int __devexit rtl8366_smi_remove(struct platform_device *pdev) 
     1959static int __devexit rtl8366s_remove(struct platform_device *pdev) 
    19621960{ 
    19631961        struct rtl8366s *rtl = platform_get_drvdata(pdev); 
    19641962 
    19651963        if (rtl) { 
    1966                 rtl8366_smi_switch_cleanup(rtl); 
    1967                 rtl8366_debugfs_remove(rtl); 
    1968                 rtl8366_smi_mii_cleanup(rtl); 
     1964                rtl8366s_switch_cleanup(rtl); 
     1965                rtl8366s_debugfs_remove(rtl); 
     1966                rtl8366s_mii_cleanup(rtl); 
    19691967                platform_set_drvdata(pdev, NULL); 
    19701968                rtl8366_smi_cleanup(&rtl->smi); 
     
    19751973} 
    19761974 
    1977 static struct platform_driver rtl8366_smi_driver = { 
     1975static struct platform_driver rtl8366s_driver = { 
    19781976        .driver = { 
    1979                 .name           = RTL8366_SMI_DRIVER_NAME, 
     1977                .name           = RTL8366S_DRIVER_NAME, 
    19801978                .owner          = THIS_MODULE, 
    19811979        }, 
    1982         .probe          = rtl8366_smi_probe, 
    1983         .remove         = __devexit_p(rtl8366_smi_remove), 
     1980        .probe          = rtl8366s_probe, 
     1981        .remove         = __devexit_p(rtl8366s_remove), 
    19841982}; 
    19851983 
    1986 static int __init rtl8366_smi_module_init(void) 
     1984static int __init rtl8366s_module_init(void) 
    19871985{ 
    19881986        int ret; 
    1989         ret = platform_driver_register(&rtl8366_smi_driver); 
     1987        ret = platform_driver_register(&rtl8366s_driver); 
    19901988        if (ret) 
    19911989                return ret; 
    19921990 
    1993         ret = phy_driver_register(&rtl8366_smi_phy_driver); 
     1991        ret = phy_driver_register(&rtl8366s_phy_driver); 
    19941992        if (ret) 
    19951993                goto err_platform_unregister; 
     
    19981996 
    19991997 err_platform_unregister: 
    2000         platform_driver_unregister(&rtl8366_smi_driver); 
     1998        platform_driver_unregister(&rtl8366s_driver); 
    20011999        return ret; 
    20022000} 
    2003 module_init(rtl8366_smi_module_init); 
    2004  
    2005 static void __exit rtl8366_smi_exit(void) 
    2006 { 
    2007         phy_driver_unregister(&rtl8366_smi_phy_driver); 
    2008         platform_driver_unregister(&rtl8366_smi_driver); 
    2009 } 
    2010 module_exit(rtl8366_smi_exit); 
    2011  
    2012 MODULE_DESCRIPTION(RTL8366_SMI_DRIVER_DESC); 
    2013 MODULE_VERSION(RTL8366_SMI_DRIVER_VER); 
     2001module_init(rtl8366s_module_init); 
     2002 
     2003static void __exit rtl8366s_module_exit(void) 
     2004{ 
     2005        phy_driver_unregister(&rtl8366s_phy_driver); 
     2006        platform_driver_unregister(&rtl8366s_driver); 
     2007} 
     2008module_exit(rtl8366s_module_exit); 
     2009 
     2010MODULE_DESCRIPTION(RTL8366S_DRIVER_DESC); 
     2011MODULE_VERSION(RTL8366S_DRIVER_VER); 
    20142012MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); 
    20152013MODULE_AUTHOR("Antti SeppÀlÀ <a.seppala@gmail.com>"); 
    20162014MODULE_LICENSE("GPL v2"); 
    2017 MODULE_ALIAS("platform:" RTL8366_SMI_DRIVER_NAME); 
     2015MODULE_ALIAS("platform:" RTL8366S_DRIVER_NAME); 
Note: See TracChangeset for help on using the changeset viewer.