Changeset 22027


Ignore:
Timestamp:
2010-07-01T20:08:32+02:00 (7 years ago)
Author:
juhosg
Message:

backfire: generic: rtl8366: move common debugfs code to rtl8366_smi.c (backport of 21981)

Location:
branches/backfire/target/linux/generic-2.6/files/drivers/net/phy
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.c

    r22025 r22027  
    1717#include <linux/skbuff.h> 
    1818 
     19#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
     20#include <linux/debugfs.h> 
     21#endif 
     22 
    1923#include "rtl8366_smi.h" 
    2024 
     
    484488} 
    485489EXPORT_SYMBOL_GPL(rtl8366_set_pvid); 
     490 
     491#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
     492int rtl8366_debugfs_open(struct inode *inode, struct file *file) 
     493{ 
     494        file->private_data = inode->i_private; 
     495        return 0; 
     496} 
     497EXPORT_SYMBOL_GPL(rtl8366_debugfs_open); 
     498 
     499static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file, 
     500                                              char __user *user_buf, 
     501                                              size_t count, loff_t *ppos) 
     502{ 
     503        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data; 
     504        int i, len = 0; 
     505        char *buf = smi->buf; 
     506 
     507        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     508                        "%2s %6s %4s %6s %6s %3s\n", 
     509                        "id", "vid","prio", "member", "untag", "fid"); 
     510 
     511        for (i = 0; i < smi->num_vlan_mc; ++i) { 
     512                struct rtl8366_vlan_mc vlanmc; 
     513 
     514                smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     515 
     516                len += snprintf(buf + len, sizeof(smi->buf) - len, 
     517                                "%2d %6d %4d 0x%04x 0x%04x %3d\n", 
     518                                i, vlanmc.vid, vlanmc.priority, 
     519                                vlanmc.member, vlanmc.untag, vlanmc.fid); 
     520        } 
     521 
     522        return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
     523} 
     524 
     525static ssize_t rtl8366_read_debugfs_reg(struct file *file, 
     526                                         char __user *user_buf, 
     527                                         size_t count, loff_t *ppos) 
     528{ 
     529        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data; 
     530        u32 t, reg = smi->dbg_reg; 
     531        int err, len = 0; 
     532        char *buf = smi->buf; 
     533 
     534        memset(buf, '\0', sizeof(smi->buf)); 
     535 
     536        err = rtl8366_smi_read_reg(smi, reg, &t); 
     537        if (err) { 
     538                len += snprintf(buf, sizeof(smi->buf), 
     539                                "Read failed (reg: 0x%04x)\n", reg); 
     540                return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
     541        } 
     542 
     543        len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n", 
     544                        reg, t); 
     545 
     546        return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
     547} 
     548 
     549static ssize_t rtl8366_write_debugfs_reg(struct file *file, 
     550                                          const char __user *user_buf, 
     551                                          size_t count, loff_t *ppos) 
     552{ 
     553        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data; 
     554        unsigned long data; 
     555        u32 reg = smi->dbg_reg; 
     556        int err; 
     557        size_t len; 
     558        char *buf = smi->buf; 
     559 
     560        len = min(count, sizeof(smi->buf) - 1); 
     561        if (copy_from_user(buf, user_buf, len)) { 
     562                dev_err(smi->parent, "copy from user failed\n"); 
     563                return -EFAULT; 
     564        } 
     565 
     566        buf[len] = '\0'; 
     567        if (len > 0 && buf[len - 1] == '\n') 
     568                buf[len - 1] = '\0'; 
     569 
     570 
     571        if (strict_strtoul(buf, 16, &data)) { 
     572                dev_err(smi->parent, "Invalid reg value %s\n", buf); 
     573        } else { 
     574                err = rtl8366_smi_write_reg(smi, reg, data); 
     575                if (err) { 
     576                        dev_err(smi->parent, 
     577                                "writing reg 0x%04x val 0x%04lx failed\n", 
     578                                reg, data); 
     579                } 
     580        } 
     581 
     582        return count; 
     583} 
     584 
     585static const struct file_operations fops_rtl8366_regs = { 
     586        .read   = rtl8366_read_debugfs_reg, 
     587        .write  = rtl8366_write_debugfs_reg, 
     588        .open   = rtl8366_debugfs_open, 
     589        .owner  = THIS_MODULE 
     590}; 
     591 
     592static const struct file_operations fops_rtl8366_vlan_mc = { 
     593        .read   = rtl8366_read_debugfs_vlan_mc, 
     594        .open   = rtl8366_debugfs_open, 
     595        .owner  = THIS_MODULE 
     596}; 
     597 
     598static void rtl8366_debugfs_init(struct rtl8366_smi *smi) 
     599{ 
     600        struct dentry *node; 
     601        struct dentry *root; 
     602 
     603        if (!smi->debugfs_root) 
     604                smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent), 
     605                                                       NULL); 
     606 
     607        if (!smi->debugfs_root) { 
     608                dev_err(smi->parent, "Unable to create debugfs dir\n"); 
     609                return; 
     610        } 
     611        root = smi->debugfs_root; 
     612 
     613        node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, 
     614                                  &smi->dbg_reg); 
     615        if (!node) { 
     616                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
     617                        "reg"); 
     618                return; 
     619        } 
     620 
     621        node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi, 
     622                                   &fops_rtl8366_regs); 
     623        if (!node) { 
     624                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
     625                        "val"); 
     626                return; 
     627        } 
     628 
     629        node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi, 
     630                                   &fops_rtl8366_vlan_mc); 
     631        if (!node) 
     632                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
     633                        "vlan_mc"); 
     634} 
     635 
     636static void rtl8366_debugfs_remove(struct rtl8366_smi *smi) 
     637{ 
     638        if (smi->debugfs_root) { 
     639                debugfs_remove_recursive(smi->debugfs_root); 
     640                smi->debugfs_root = NULL; 
     641        } 
     642} 
     643#else 
     644static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {} 
     645static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {} 
     646#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */ 
    486647 
    487648static int rtl8366_smi_mii_init(struct rtl8366_smi *smi) 
     
    565726                goto err_free_sck; 
    566727 
     728        rtl8366_debugfs_init(smi); 
     729 
    567730        return 0; 
    568731 
     
    578741void rtl8366_smi_cleanup(struct rtl8366_smi *smi) 
    579742{ 
     743        rtl8366_debugfs_remove(smi); 
    580744        rtl8366_smi_mii_cleanup(smi); 
    581745        gpio_free(smi->gpio_sck); 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.h

    r22026 r22027  
    1717struct rtl8366_vlan_ops; 
    1818struct mii_bus; 
     19struct dentry; 
     20struct inode; 
     21struct file; 
    1922 
    2023struct rtl8366_smi { 
     
    3336 
    3437        char                    buf[4096]; 
     38#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
     39        struct dentry           *debugfs_root; 
     40        u16                     dbg_reg; 
     41#endif 
    3542}; 
    3643 
     
    8087int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid); 
    8188 
     89#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
     90int rtl8366_debugfs_open(struct inode *inode, struct file *file); 
     91#endif 
     92 
    8293#endif /*  _RTL8366_SMI_H */ 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c

    r22026 r22027  
    165165        struct rtl8366_smi      smi; 
    166166        struct switch_dev       dev; 
    167 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    168         struct dentry           *debugfs_root; 
    169 #endif 
    170167}; 
    171168 
     
    190187        u16     fid:3; 
    191188}; 
    192  
    193 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    194 u16 gl_dbg_reg; 
    195 #endif 
    196189 
    197190struct mib_counter { 
     
    686679 
    687680#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    688 static int rtl8366rb_debugfs_open(struct inode *inode, struct file *file) 
    689 { 
    690         file->private_data = inode->i_private; 
    691         return 0; 
    692 } 
    693  
    694681static ssize_t rtl8366rb_read_debugfs_mibs(struct file *file, 
    695682                                          char __user *user_buf, 
    696683                                          size_t count, loff_t *ppos) 
    697684{ 
    698         struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data; 
    699         struct rtl8366_smi *smi = &rtl->smi; 
     685        struct rtl8366_smi *smi = file->private_data; 
    700686        int i, j, len = 0; 
    701687        char *buf = smi->buf; 
     
    728714} 
    729715 
    730 static ssize_t rtl8366rb_read_debugfs_vlan_mc(struct file *file, 
    731                                               char __user *user_buf, 
    732                                               size_t count, loff_t *ppos) 
    733 { 
    734         struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data; 
    735         struct rtl8366_smi *smi = &rtl->smi; 
    736         int i, len = 0; 
    737         char *buf = smi->buf; 
    738  
    739         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    740                         "%2s %6s %4s %6s %6s %3s\n", 
    741                         "id", "vid","prio", "member", "untag", "fid"); 
    742  
    743         for (i = 0; i < RTL8366RB_NUM_VLANS; ++i) { 
    744                 struct rtl8366_vlan_mc vlanmc; 
    745  
    746                 rtl8366rb_get_vlan_mc(smi, i, &vlanmc); 
    747  
    748                 len += snprintf(buf + len, sizeof(smi->buf) - len, 
    749                                 "%2d %6d %4d 0x%04x 0x%04x %3d\n", 
    750                                 i, vlanmc.vid, vlanmc.priority, 
    751                                 vlanmc.member, vlanmc.untag, vlanmc.fid); 
    752         } 
    753  
    754         return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    755 } 
    756  
    757 static ssize_t rtl8366rb_read_debugfs_reg(struct file *file, 
    758                                          char __user *user_buf, 
    759                                          size_t count, loff_t *ppos) 
    760 { 
    761         struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data; 
    762         struct rtl8366_smi *smi = &rtl->smi; 
    763         u32 t, reg = gl_dbg_reg; 
    764         int err, len = 0; 
    765         char *buf = smi->buf; 
    766  
    767         memset(buf, '\0', sizeof(smi->buf)); 
    768  
    769         err = rtl8366_smi_read_reg(smi, reg, &t); 
    770         if (err) { 
    771                 len += snprintf(buf, sizeof(smi->buf), 
    772                                 "Read failed (reg: 0x%04x)\n", reg); 
    773                 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    774         } 
    775  
    776         len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n", 
    777                         reg, t); 
    778  
    779         return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    780 } 
    781  
    782 static ssize_t rtl8366rb_write_debugfs_reg(struct file *file, 
    783                                           const char __user *user_buf, 
    784                                           size_t count, loff_t *ppos) 
    785 { 
    786         struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data; 
    787         struct rtl8366_smi *smi = &rtl->smi; 
    788         unsigned long data; 
    789         u32 reg = gl_dbg_reg; 
    790         int err; 
    791         size_t len; 
    792         char *buf = smi->buf; 
    793  
    794         len = min(count, sizeof(smi->buf) - 1); 
    795         if (copy_from_user(buf, user_buf, len)) { 
    796                 dev_err(rtl->parent, "copy from user failed\n"); 
    797                 return -EFAULT; 
    798         } 
    799  
    800         buf[len] = '\0'; 
    801         if (len > 0 && buf[len - 1] == '\n') 
    802                 buf[len - 1] = '\0'; 
    803  
    804  
    805         if (strict_strtoul(buf, 16, &data)) { 
    806                 dev_err(rtl->parent, "Invalid reg value %s\n", buf); 
    807         } else { 
    808                 err = rtl8366_smi_write_reg(smi, reg, data); 
    809                 if (err) { 
    810                         dev_err(rtl->parent, 
    811                                 "writing reg 0x%04x val 0x%04lx failed\n", 
    812                                 reg, data); 
    813                 } 
    814         } 
    815  
    816         return count; 
    817 } 
    818  
    819 static const struct file_operations fops_rtl8366rb_regs = { 
    820         .read = rtl8366rb_read_debugfs_reg, 
    821         .write = rtl8366rb_write_debugfs_reg, 
    822         .open = rtl8366rb_debugfs_open, 
     716static const struct file_operations fops_rtl8366rb_mibs = { 
     717        .read = rtl8366rb_read_debugfs_mibs, 
     718        .open = rtl8366_debugfs_open, 
    823719        .owner = THIS_MODULE 
    824720}; 
    825721 
    826 static const struct file_operations fops_rtl8366rb_vlan_mc = { 
    827         .read = rtl8366rb_read_debugfs_vlan_mc, 
    828         .open = rtl8366rb_debugfs_open, 
    829         .owner = THIS_MODULE 
    830 }; 
    831  
    832 static const struct file_operations fops_rtl8366rb_mibs = { 
    833         .read = rtl8366rb_read_debugfs_mibs, 
    834         .open = rtl8366rb_debugfs_open, 
    835         .owner = THIS_MODULE 
    836 }; 
    837  
    838 static void rtl8366rb_debugfs_init(struct rtl8366rb *rtl) 
     722static void rtl8366rb_debugfs_init(struct rtl8366_smi *smi) 
    839723{ 
    840724        struct dentry *node; 
    841         struct dentry *root; 
    842  
    843         if (!rtl->debugfs_root) 
    844                 rtl->debugfs_root = debugfs_create_dir("rtl8366rb", NULL); 
    845  
    846         if (!rtl->debugfs_root) { 
    847                 dev_err(rtl->parent, "Unable to create debugfs dir\n"); 
     725 
     726        if (!smi->debugfs_root) 
    848727                return; 
    849         } 
    850         root = rtl->debugfs_root; 
    851  
    852         node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &gl_dbg_reg); 
    853         if (!node) { 
    854                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    855                         "reg"); 
    856                 return; 
    857         } 
    858  
    859         node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, rtl, 
    860                                    &fops_rtl8366rb_regs); 
    861         if (!node) { 
    862                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    863                         "val"); 
    864                 return; 
    865         } 
    866  
    867         node = debugfs_create_file("vlan_mc", S_IRUSR, root, rtl, 
    868                                    &fops_rtl8366rb_vlan_mc); 
    869         if (!node) { 
    870                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    871                         "vlan_mc"); 
    872                 return; 
    873         } 
    874  
    875         node = debugfs_create_file("mibs", S_IRUSR, root, rtl, 
     728 
     729        node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi, 
    876730                                   &fops_rtl8366rb_mibs); 
    877         if (!node) { 
    878                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
     731        if (!node) 
     732                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
    879733                        "mibs"); 
    880                 return; 
    881         } 
    882 } 
    883  
    884 static void rtl8366rb_debugfs_remove(struct rtl8366rb *rtl) 
    885 { 
    886         if (rtl->debugfs_root) { 
    887                 debugfs_remove_recursive(rtl->debugfs_root); 
    888                 rtl->debugfs_root = NULL; 
    889         } 
    890734} 
    891735 
    892736#else 
    893 static inline void rtl8366rb_debugfs_init(struct rtl8366rb *rtl) {} 
    894 static inline void rtl8366rb_debugfs_remove(struct rtl8366rb *rtl) {} 
     737static inline void rtl8366rb_debugfs_init(struct rtl8366_smi *smi) {} 
    895738#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */ 
    896739 
     
    13991242        int ret; 
    14001243 
    1401         rtl8366rb_debugfs_init(rtl); 
     1244        rtl8366rb_debugfs_init(smi); 
    14021245 
    14031246        ret = rtl8366rb_reset_chip(smi); 
     
    15491392        if (rtl) { 
    15501393                rtl8366rb_switch_cleanup(rtl); 
    1551                 rtl8366rb_debugfs_remove(rtl); 
    15521394                platform_set_drvdata(pdev, NULL); 
    15531395                rtl8366_smi_cleanup(&rtl->smi); 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366s.c

    r22026 r22027  
    171171        struct rtl8366_smi      smi; 
    172172        struct switch_dev       dev; 
    173 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    174         struct dentry           *debugfs_root; 
    175 #endif 
    176173}; 
    177174 
     
    196193        u16     member:6; 
    197194}; 
    198  
    199 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    200 u16 g_dbg_reg; 
    201 #endif 
    202195 
    203196struct mib_counter { 
     
    675668 
    676669#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    677 static int rtl8366s_debugfs_open(struct inode *inode, struct file *file) 
    678 { 
    679         file->private_data = inode->i_private; 
    680         return 0; 
    681 } 
    682  
    683670static ssize_t rtl8366s_read_debugfs_mibs(struct file *file, 
    684671                                          char __user *user_buf, 
    685672                                          size_t count, loff_t *ppos) 
    686673{ 
    687         struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
    688         struct rtl8366_smi *smi = &rtl->smi; 
     674        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data; 
    689675        int i, j, len = 0; 
    690676        char *buf = smi->buf; 
     
    717703} 
    718704 
    719 static ssize_t rtl8366s_read_debugfs_vlan_mc(struct file *file, 
    720                                              char __user *user_buf, 
    721                                              size_t count, loff_t *ppos) 
    722 { 
    723         struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
    724         struct rtl8366_smi *smi = &rtl->smi; 
    725         int i, len = 0; 
    726         char *buf = smi->buf; 
    727  
    728         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    729                         "%2s %6s %4s %6s %6s %3s\n", 
    730                         "id", "vid","prio", "member", "untag", "fid"); 
    731  
    732         for (i = 0; i < RTL8366S_NUM_VLANS; ++i) { 
    733                 struct rtl8366_vlan_mc vlanmc; 
    734  
    735                 rtl8366s_get_vlan_mc(smi, i, &vlanmc); 
    736  
    737                 len += snprintf(buf + len, sizeof(smi->buf) - len, 
    738                                 "%2d %6d %4d 0x%04x 0x%04x %3d\n", 
    739                                 i, vlanmc.vid, vlanmc.priority, 
    740                                 vlanmc.member, vlanmc.untag, vlanmc.fid); 
    741         } 
    742  
    743         return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    744 } 
    745  
    746 static ssize_t rtl8366s_read_debugfs_reg(struct file *file, 
    747                                          char __user *user_buf, 
    748                                          size_t count, loff_t *ppos) 
    749 { 
    750         struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
    751         struct rtl8366_smi *smi = &rtl->smi; 
    752         u32 t, reg = g_dbg_reg; 
    753         int err, len = 0; 
    754         char *buf = smi->buf; 
    755  
    756         memset(buf, '\0', sizeof(smi->buf)); 
    757  
    758         err = rtl8366_smi_read_reg(smi, reg, &t); 
    759         if (err) { 
    760                 len += snprintf(buf, sizeof(smi->buf), 
    761                                 "Read failed (reg: 0x%04x)\n", reg); 
    762                 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    763         } 
    764  
    765         len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n", 
    766                         reg, t); 
    767  
    768         return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
    769 } 
    770  
    771 static ssize_t rtl8366s_write_debugfs_reg(struct file *file, 
    772                                           const char __user *user_buf, 
    773                                           size_t count, loff_t *ppos) 
    774 { 
    775         struct rtl8366s *rtl = (struct rtl8366s *)file->private_data; 
    776         struct rtl8366_smi *smi = &rtl->smi; 
    777         unsigned long data; 
    778         u32 reg = g_dbg_reg; 
    779         int err; 
    780         size_t len; 
    781         char *buf = smi->buf; 
    782  
    783         len = min(count, sizeof(smi->buf) - 1); 
    784         if (copy_from_user(buf, user_buf, len)) { 
    785                 dev_err(rtl->parent, "copy from user failed\n"); 
    786                 return -EFAULT; 
    787         } 
    788  
    789         buf[len] = '\0'; 
    790         if (len > 0 && buf[len - 1] == '\n') 
    791                 buf[len - 1] = '\0'; 
    792  
    793  
    794         if (strict_strtoul(buf, 16, &data)) { 
    795                 dev_err(rtl->parent, "Invalid reg value %s\n", buf); 
    796         } else { 
    797                 err = rtl8366_smi_write_reg(smi, reg, data); 
    798                 if (err) { 
    799                         dev_err(rtl->parent, 
    800                                 "writing reg 0x%04x val 0x%04lx failed\n", 
    801                                 reg, data); 
    802                 } 
    803         } 
    804  
    805         return count; 
    806 } 
    807  
    808 static const struct file_operations fops_rtl8366s_regs = { 
    809         .read = rtl8366s_read_debugfs_reg, 
    810         .write = rtl8366s_write_debugfs_reg, 
    811         .open = rtl8366s_debugfs_open, 
     705static const struct file_operations fops_rtl8366s_mibs = { 
     706        .read = rtl8366s_read_debugfs_mibs, 
     707        .open = rtl8366_debugfs_open, 
    812708        .owner = THIS_MODULE 
    813709}; 
    814710 
    815 static const struct file_operations fops_rtl8366s_vlan_mc = { 
    816         .read = rtl8366s_read_debugfs_vlan_mc, 
    817         .open = rtl8366s_debugfs_open, 
    818         .owner = THIS_MODULE 
    819 }; 
    820  
    821 static const struct file_operations fops_rtl8366s_mibs = { 
    822         .read = rtl8366s_read_debugfs_mibs, 
    823         .open = rtl8366s_debugfs_open, 
    824         .owner = THIS_MODULE 
    825 }; 
    826  
    827 static void rtl8366s_debugfs_init(struct rtl8366s *rtl) 
     711static void rtl8366s_debugfs_init(struct rtl8366_smi *smi) 
    828712{ 
    829713        struct dentry *node; 
    830         struct dentry *root; 
    831  
    832         if (!rtl->debugfs_root) 
    833                 rtl->debugfs_root = debugfs_create_dir("rtl8366s", NULL); 
    834  
    835         if (!rtl->debugfs_root) { 
    836                 dev_err(rtl->parent, "Unable to create debugfs dir\n"); 
     714 
     715        if (!smi->debugfs_root) 
    837716                return; 
    838         } 
    839         root = rtl->debugfs_root; 
    840  
    841         node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &g_dbg_reg); 
    842         if (!node) { 
    843                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    844                         "reg"); 
    845                 return; 
    846         } 
    847  
    848         node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, rtl, 
    849                                    &fops_rtl8366s_regs); 
    850         if (!node) { 
    851                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    852                         "val"); 
    853                 return; 
    854         } 
    855  
    856         node = debugfs_create_file("vlan_mc", S_IRUSR, root, rtl, 
    857                                    &fops_rtl8366s_vlan_mc); 
    858         if (!node) { 
    859                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
    860                         "vlan_mc"); 
    861                 return; 
    862         } 
    863  
    864         node = debugfs_create_file("mibs", S_IRUSR, root, rtl, 
     717 
     718        node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi, 
    865719                                   &fops_rtl8366s_mibs); 
    866         if (!node) { 
    867                 dev_err(rtl->parent, "Creating debugfs file '%s' failed\n", 
     720        if (!node) 
     721                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
    868722                        "mibs"); 
    869                 return; 
    870         } 
    871 } 
    872  
    873 static void rtl8366s_debugfs_remove(struct rtl8366s *rtl) 
    874 { 
    875         if (rtl->debugfs_root) { 
    876                 debugfs_remove_recursive(rtl->debugfs_root); 
    877                 rtl->debugfs_root = NULL; 
    878         } 
    879 } 
    880  
     723} 
    881724#else 
    882 static inline void rtl8366s_debugfs_init(struct rtl8366s *rtl) {} 
    883 static inline void rtl8366s_debugfs_remove(struct rtl8366s *rtl) {} 
     725static inline void rtl8366s_debugfs_init(struct rtl8366_smi *smi) {} 
    884726#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */ 
    885727 
     
    13891231        int ret; 
    13901232 
    1391         rtl8366s_debugfs_init(rtl); 
     1233        rtl8366s_debugfs_init(smi); 
    13921234 
    13931235        ret = rtl8366s_reset_chip(smi); 
     
    15391381        if (rtl) { 
    15401382                rtl8366s_switch_cleanup(rtl); 
    1541                 rtl8366s_debugfs_remove(rtl); 
    15421383                platform_set_drvdata(pdev, NULL); 
    15431384                rtl8366_smi_cleanup(&rtl->smi); 
Note: See TracChangeset for help on using the changeset viewer.