Changeset 22025


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

backfire: generic: rtl8366: move common VLAN handling functions to rtl8366_smi.c (backport of 21979)

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

    r21938 r22025  
    281281} 
    282282EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr); 
     283 
     284static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used) 
     285{ 
     286        int err; 
     287        int i; 
     288 
     289        *used = 0; 
     290        for (i = 0; i < smi->num_ports; i++) { 
     291                int index = 0; 
     292 
     293                err = smi->ops->get_mc_index(smi, i, &index); 
     294                if (err) 
     295                        return err; 
     296 
     297                if (mc_index == index) { 
     298                        *used = 1; 
     299                        break; 
     300                } 
     301        } 
     302 
     303        return 0; 
     304} 
     305 
     306int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag, 
     307                     u32 fid) 
     308{ 
     309        struct rtl8366_vlan_4k vlan4k; 
     310        int err; 
     311        int i; 
     312 
     313        /* Update the 4K table */ 
     314        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
     315        if (err) 
     316                return err; 
     317 
     318        vlan4k.member = member; 
     319        vlan4k.untag = untag; 
     320        vlan4k.fid = fid; 
     321        err = smi->ops->set_vlan_4k(smi, &vlan4k); 
     322        if (err) 
     323                return err; 
     324 
     325        /* Try to find an existing MC entry for this VID */ 
     326        for (i = 0; i < smi->num_vlan_mc; i++) { 
     327                struct rtl8366_vlan_mc vlanmc; 
     328 
     329                err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     330                if (err) 
     331                        return err; 
     332 
     333                if (vid == vlanmc.vid) { 
     334                        /* update the MC entry */ 
     335                        vlanmc.member = member; 
     336                        vlanmc.untag = untag; 
     337                        vlanmc.fid = fid; 
     338 
     339                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     340                        break; 
     341                } 
     342        } 
     343 
     344        return err; 
     345} 
     346EXPORT_SYMBOL_GPL(rtl8366_set_vlan); 
     347 
     348int rtl8366_reset_vlan(struct rtl8366_smi *smi) 
     349{ 
     350        struct rtl8366_vlan_mc vlanmc; 
     351        int err; 
     352        int i; 
     353 
     354        /* clear VLAN member configurations */ 
     355        vlanmc.vid = 0; 
     356        vlanmc.priority = 0; 
     357        vlanmc.member = 0; 
     358        vlanmc.untag = 0; 
     359        vlanmc.fid = 0; 
     360        for (i = 0; i < smi->num_vlan_mc; i++) { 
     361                err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     362                if (err) 
     363                        return err; 
     364        } 
     365 
     366        for (i = 0; i < smi->num_ports; i++) { 
     367                if (i == smi->cpu_port) 
     368                        continue; 
     369 
     370                err = rtl8366_set_vlan(smi, (i + 1), 
     371                                        (1 << i) | (1 << smi->cpu_port), 
     372                                        (1 << i) | (1 << smi->cpu_port), 
     373                                        0); 
     374                if (err) 
     375                        return err; 
     376 
     377                err = rtl8366_set_pvid(smi, i, (i + 1)); 
     378                if (err) 
     379                        return err; 
     380        } 
     381 
     382        return 0; 
     383} 
     384EXPORT_SYMBOL_GPL(rtl8366_reset_vlan); 
     385 
     386int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val) 
     387{ 
     388        struct rtl8366_vlan_mc vlanmc; 
     389        int err; 
     390        int index; 
     391 
     392        err = smi->ops->get_mc_index(smi, port, &index); 
     393        if (err) 
     394                return err; 
     395 
     396        err = smi->ops->get_vlan_mc(smi, index, &vlanmc); 
     397        if (err) 
     398                return err; 
     399 
     400        *val = vlanmc.vid; 
     401        return 0; 
     402} 
     403EXPORT_SYMBOL_GPL(rtl8366_get_pvid); 
     404 
     405int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid) 
     406{ 
     407        struct rtl8366_vlan_mc vlanmc; 
     408        struct rtl8366_vlan_4k vlan4k; 
     409        int err; 
     410        int i; 
     411 
     412        /* Try to find an existing MC entry for this VID */ 
     413        for (i = 0; i < smi->num_vlan_mc; i++) { 
     414                err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     415                if (err) 
     416                        return err; 
     417 
     418                if (vid == vlanmc.vid) { 
     419                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     420                        if (err) 
     421                                return err; 
     422 
     423                        err = smi->ops->set_mc_index(smi, port, i); 
     424                        return err; 
     425                } 
     426        } 
     427 
     428        /* We have no MC entry for this VID, try to find an empty one */ 
     429        for (i = 0; i < smi->num_vlan_mc; i++) { 
     430                err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     431                if (err) 
     432                        return err; 
     433 
     434                if (vlanmc.vid == 0 && vlanmc.member == 0) { 
     435                        /* Update the entry from the 4K table */ 
     436                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
     437                        if (err) 
     438                                return err; 
     439 
     440                        vlanmc.vid = vid; 
     441                        vlanmc.member = vlan4k.member; 
     442                        vlanmc.untag = vlan4k.untag; 
     443                        vlanmc.fid = vlan4k.fid; 
     444                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     445                        if (err) 
     446                                return err; 
     447 
     448                        err = smi->ops->set_mc_index(smi, port, i); 
     449                        return err; 
     450                } 
     451        } 
     452 
     453        /* MC table is full, try to find an unused entry and replace it */ 
     454        for (i = 0; i < smi->num_vlan_mc; i++) { 
     455                int used; 
     456 
     457                err = rtl8366_mc_is_used(smi, i, &used); 
     458                if (err) 
     459                        return err; 
     460 
     461                if (!used) { 
     462                        /* Update the entry from the 4K table */ 
     463                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
     464                        if (err) 
     465                                return err; 
     466 
     467                        vlanmc.vid = vid; 
     468                        vlanmc.member = vlan4k.member; 
     469                        vlanmc.untag = vlan4k.untag; 
     470                        vlanmc.fid = vlan4k.fid; 
     471                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     472                        if (err) 
     473                                return err; 
     474 
     475                        err = smi->ops->set_mc_index(smi, port, i); 
     476                        return err; 
     477                } 
     478        } 
     479 
     480        dev_err(smi->parent, 
     481                "all VLAN member configurations are in use\n"); 
     482 
     483        return -ENOSPC; 
     484} 
     485EXPORT_SYMBOL_GPL(rtl8366_set_pvid); 
    283486 
    284487static int rtl8366_smi_mii_init(struct rtl8366_smi *smi) 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.h

    r22024 r22025  
    7272int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data); 
    7373 
     74int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag, 
     75                     u32 fid); 
     76int rtl8366_reset_vlan(struct rtl8366_smi *smi); 
     77int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val); 
     78int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid); 
     79 
    7480#endif /*  _RTL8366_SMI_H */ 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c

    r22024 r22025  
    672672} 
    673673 
    674 static int rtl8366rb_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, 
    675                               u32 untag, u32 fid) 
    676 { 
    677         struct rtl8366_vlan_4k vlan4k; 
    678         int err; 
    679         int i; 
    680  
    681         /* Update the 4K table */ 
    682         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    683         if (err) 
    684                 return err; 
    685  
    686         vlan4k.member = member; 
    687         vlan4k.untag = untag; 
    688         vlan4k.fid = fid; 
    689         err = smi->ops->set_vlan_4k(smi, &vlan4k); 
    690         if (err) 
    691                 return err; 
    692  
    693         /* Try to find an existing MC entry for this VID */ 
    694         for (i = 0; i < smi->num_vlan_mc; i++) { 
    695                 struct rtl8366_vlan_mc vlanmc; 
    696  
    697                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    698                 if (err) 
    699                         return err; 
    700  
    701                 if (vid == vlanmc.vid) { 
    702                         /* update the MC entry */ 
    703                         vlanmc.member = member; 
    704                         vlanmc.untag = untag; 
    705                         vlanmc.fid = fid; 
    706  
    707                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    708                         break; 
    709                 } 
    710         } 
    711  
    712         return err; 
    713 } 
    714  
    715 static int rtl8366rb_get_pvid(struct rtl8366_smi *smi, int port, int *val) 
    716 { 
    717         struct rtl8366_vlan_mc vlanmc; 
    718         int err; 
    719         int index; 
    720  
    721         err = smi->ops->get_mc_index(smi, port, &index); 
    722         if (err) 
    723                 return err; 
    724  
    725         err = smi->ops->get_vlan_mc(smi, index, &vlanmc); 
    726         if (err) 
    727                 return err; 
    728  
    729         *val = vlanmc.vid; 
    730         return 0; 
    731 } 
    732  
    733 static int rtl8366rb_mc_is_used(struct rtl8366_smi *smi, int mc_index, 
    734                                 int *used) 
    735 { 
    736         int err; 
    737         int i; 
    738  
    739         *used = 0; 
    740         for (i = 0; i < smi->num_ports; i++) { 
    741                 int index = 0; 
    742  
    743                 err = smi->ops->get_mc_index(smi, i, &index); 
    744                 if (err) 
    745                         return err; 
    746  
    747                 if (mc_index == index) { 
    748                         *used = 1; 
    749                         break; 
    750                 } 
    751         } 
    752  
    753         return 0; 
    754 } 
    755  
    756 static int rtl8366rb_set_pvid(struct rtl8366_smi *smi, unsigned port, 
    757                               unsigned vid) 
    758 { 
    759         struct rtl8366_vlan_mc vlanmc; 
    760         struct rtl8366_vlan_4k vlan4k; 
    761         int err; 
    762         int i; 
    763  
    764         /* Try to find an existing MC entry for this VID */ 
    765         for (i = 0; i < smi->num_vlan_mc; i++) { 
    766                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    767                 if (err) 
    768                         return err; 
    769  
    770                 if (vid == vlanmc.vid) { 
    771                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    772                         if (err) 
    773                                 return err; 
    774  
    775                         err = smi->ops->set_mc_index(smi, port, i); 
    776                         return err; 
    777                 } 
    778         } 
    779  
    780         /* We have no MC entry for this VID, try to find an empty one */ 
    781         for (i = 0; i < smi->num_vlan_mc; i++) { 
    782                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    783                 if (err) 
    784                         return err; 
    785  
    786                 if (vlanmc.vid == 0 && vlanmc.member == 0) { 
    787                         /* Update the entry from the 4K table */ 
    788                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    789                         if (err) 
    790                                 return err; 
    791  
    792                         vlanmc.vid = vid; 
    793                         vlanmc.member = vlan4k.member; 
    794                         vlanmc.untag = vlan4k.untag; 
    795                         vlanmc.fid = vlan4k.fid; 
    796                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    797                         if (err) 
    798                                 return err; 
    799  
    800                         err = smi->ops->set_mc_index(smi, port, i); 
    801                         return err; 
    802                 } 
    803         } 
    804  
    805         /* MC table is full, try to find an unused entry and replace it */ 
    806         for (i = 0; i < smi->num_vlan_mc; i++) { 
    807                 int used; 
    808  
    809                 err = rtl8366rb_mc_is_used(smi, i, &used); 
    810                 if (err) 
    811                         return err; 
    812  
    813                 if (!used) { 
    814                         /* Update the entry from the 4K table */ 
    815                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    816                         if (err) 
    817                                 return err; 
    818  
    819                         vlanmc.vid = vid; 
    820                         vlanmc.member = vlan4k.member; 
    821                         vlanmc.untag = vlan4k.untag; 
    822                         vlanmc.fid = vlan4k.fid; 
    823                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    824                         if (err) 
    825                                 return err; 
    826  
    827                         err = smi->ops->set_mc_index(smi, port, i); 
    828                         return err; 
    829                 } 
    830         } 
    831  
    832         dev_err(smi->parent, 
    833                 "all VLAN member configurations are in use\n"); 
    834  
    835         return -ENOSPC; 
    836 } 
    837  
    838674static int rtl8366rb_vlan_set_vlan(struct rtl8366_smi *smi, int enable) 
    839675{ 
     
    848684                                RTL8366RB_CHIP_CTRL_VLAN_4KTB, 
    849685                                (enable) ? RTL8366RB_CHIP_CTRL_VLAN_4KTB : 0); 
    850 } 
    851  
    852 static int rtl8366rb_reset_vlan(struct rtl8366_smi *smi) 
    853 { 
    854         struct rtl8366_vlan_mc vlanmc; 
    855         int err; 
    856         int i; 
    857  
    858         /* clear VLAN member configurations */ 
    859         vlanmc.vid = 0; 
    860         vlanmc.priority = 0; 
    861         vlanmc.member = 0; 
    862         vlanmc.untag = 0; 
    863         vlanmc.fid = 0; 
    864         for (i = 0; i < smi->num_vlan_mc; i++) { 
    865                 err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    866                 if (err) 
    867                         return err; 
    868         } 
    869  
    870         for (i = 0; i < smi->num_ports; i++) { 
    871                 if (i == smi->cpu_port) 
    872                         continue; 
    873  
    874                 err = rtl8366rb_set_vlan(smi, (i + 1), 
    875                                          (1 << i) | (1 << smi->cpu_port), 
    876                                          (1 << i) | (1 << smi->cpu_port), 
    877                                          0); 
    878                 if (err) 
    879                         return err; 
    880  
    881                 err = rtl8366rb_set_pvid(smi, i, (i + 1)); 
    882                 if (err) 
    883                         return err; 
    884         } 
    885  
    886         return 0; 
    887686} 
    888687 
     
    14111210        } 
    14121211 
    1413         return rtl8366rb_set_vlan(smi, val->port_vlan, member, untag, 0); 
     1212        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0); 
    14141213} 
    14151214 
     
    14171216{ 
    14181217        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1419         return rtl8366rb_get_pvid(smi, port, val); 
     1218        return rtl8366_get_pvid(smi, port, val); 
    14201219} 
    14211220 
     
    14231222{ 
    14241223        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1425         return rtl8366rb_set_pvid(smi, port, val); 
     1224        return rtl8366_set_pvid(smi, port, val); 
    14261225} 
    14271226 
     
    14391238                return err; 
    14401239 
    1441         return rtl8366rb_reset_vlan(smi); 
     1240        return rtl8366_reset_vlan(smi); 
    14421241} 
    14431242 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366s.c

    r22024 r22025  
    662662} 
    663663 
    664 static int rtl8366s_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, 
    665                              u32 untag, u32 fid) 
    666 { 
    667         struct rtl8366_vlan_4k vlan4k; 
    668         int err; 
    669         int i; 
    670  
    671         /* Update the 4K table */ 
    672         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    673         if (err) 
    674                 return err; 
    675  
    676         vlan4k.member = member; 
    677         vlan4k.untag = untag; 
    678         vlan4k.fid = fid; 
    679         err = smi->ops->set_vlan_4k(smi, &vlan4k); 
    680         if (err) 
    681                 return err; 
    682  
    683         /* Try to find an existing MC entry for this VID */ 
    684         for (i = 0; i < smi->num_vlan_mc; i++) { 
    685                 struct rtl8366_vlan_mc vlanmc; 
    686  
    687                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    688                 if (err) 
    689                         return err; 
    690  
    691                 if (vid == vlanmc.vid) { 
    692                         /* update the MC entry */ 
    693                         vlanmc.member = member; 
    694                         vlanmc.untag = untag; 
    695                         vlanmc.fid = fid; 
    696  
    697                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    698                         break; 
    699                 } 
    700         } 
    701  
    702         return err; 
    703 } 
    704  
    705 static int rtl8366s_get_pvid(struct rtl8366_smi *smi, int port, int *val) 
    706 { 
    707         struct rtl8366_vlan_mc vlanmc; 
    708         int err; 
    709         int index; 
    710  
    711         err = smi->ops->get_mc_index(smi, port, &index); 
    712         if (err) 
    713                 return err; 
    714  
    715         err = smi->ops->get_vlan_mc(smi, index, &vlanmc); 
    716         if (err) 
    717                 return err; 
    718  
    719         *val = vlanmc.vid; 
    720         return 0; 
    721 } 
    722  
    723 static int rtl8366s_mc_is_used(struct rtl8366_smi *smi, int mc_index, 
    724                                int *used) 
    725 { 
    726         int err; 
    727         int i; 
    728  
    729         *used = 0; 
    730         for (i = 0; i < smi->num_ports; i++) { 
    731                 int index = 0; 
    732  
    733                 err = smi->ops->get_mc_index(smi, i, &index); 
    734                 if (err) 
    735                         return err; 
    736  
    737                 if (mc_index == index) { 
    738                         *used = 1; 
    739                         break; 
    740                 } 
    741         } 
    742  
    743         return 0; 
    744 } 
    745  
    746 static int rtl8366s_set_pvid(struct rtl8366_smi *smi, unsigned port, 
    747                              unsigned vid) 
    748 { 
    749         struct rtl8366_vlan_mc vlanmc; 
    750         struct rtl8366_vlan_4k vlan4k; 
    751         int err; 
    752         int i; 
    753  
    754         /* Try to find an existing MC entry for this VID */ 
    755         for (i = 0; i < smi->num_vlan_mc; i++) { 
    756                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    757                 if (err) 
    758                         return err; 
    759  
    760                 if (vid == vlanmc.vid) { 
    761                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    762                         if (err) 
    763                                 return err; 
    764  
    765                         err = smi->ops->set_mc_index(smi, port, i); 
    766                         return err; 
    767                 } 
    768         } 
    769  
    770         /* We have no MC entry for this VID, try to find an empty one */ 
    771         for (i = 0; i < smi->num_vlan_mc; i++) { 
    772                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    773                 if (err) 
    774                         return err; 
    775  
    776                 if (vlanmc.vid == 0 && vlanmc.member == 0) { 
    777                         /* Update the entry from the 4K table */ 
    778                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    779                         if (err) 
    780                                 return err; 
    781  
    782                         vlanmc.vid = vid; 
    783                         vlanmc.member = vlan4k.member; 
    784                         vlanmc.untag = vlan4k.untag; 
    785                         vlanmc.fid = vlan4k.fid; 
    786                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    787                         if (err) 
    788                                 return err; 
    789  
    790                         err = smi->ops->set_mc_index(smi, port, i); 
    791                         return err; 
    792                 } 
    793         } 
    794  
    795         /* MC table is full, try to find an unused entry and replace it */ 
    796         for (i = 0; i < smi->num_vlan_mc; i++) { 
    797                 int used; 
    798  
    799                 err = rtl8366s_mc_is_used(smi, i, &used); 
    800                 if (err) 
    801                         return err; 
    802  
    803                 if (!used) { 
    804                         /* Update the entry from the 4K table */ 
    805                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    806                         if (err) 
    807                                 return err; 
    808  
    809                         vlanmc.vid = vid; 
    810                         vlanmc.member = vlan4k.member; 
    811                         vlanmc.untag = vlan4k.untag; 
    812                         vlanmc.fid = vlan4k.fid; 
    813                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    814                         if (err) 
    815                                 return err; 
    816  
    817                         err = smi->ops->set_mc_index(smi, port, i); 
    818                         return err; 
    819                 } 
    820         } 
    821  
    822         dev_err(smi->parent, 
    823                 "all VLAN member configurations are in use\n"); 
    824  
    825         return -ENOSPC; 
    826 } 
    827  
    828664static int rtl8366s_vlan_set_vlan(struct rtl8366_smi *smi, int enable) 
    829665{ 
     
    837673        return rtl8366_smi_rmwr(smi, RTL8366S_VLAN_TB_CTRL_REG, 
    838674                                1, (enable) ? 1 : 0); 
    839 } 
    840  
    841 static int rtl8366s_reset_vlan(struct rtl8366_smi *smi) 
    842 { 
    843         struct rtl8366_vlan_mc vlanmc; 
    844         int err; 
    845         int i; 
    846  
    847         /* clear VLAN member configurations */ 
    848         vlanmc.vid = 0; 
    849         vlanmc.priority = 0; 
    850         vlanmc.member = 0; 
    851         vlanmc.untag = 0; 
    852         vlanmc.fid = 0; 
    853         for (i = 0; i < smi->num_vlan_mc; i++) { 
    854                 err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    855                 if (err) 
    856                         return err; 
    857         } 
    858  
    859         for (i = 0; i < smi->num_ports; i++) { 
    860                 if (i == smi->cpu_port) 
    861                         continue; 
    862  
    863                 err = rtl8366s_set_vlan(smi, (i + 1), 
    864                                          (1 << i) | (1 << smi->cpu_port), 
    865                                          (1 << i) | (1 << smi->cpu_port), 
    866                                          0); 
    867                 if (err) 
    868                         return err; 
    869  
    870                 err = rtl8366s_set_pvid(smi, i, (i + 1)); 
    871                 if (err) 
    872                         return err; 
    873         } 
    874  
    875         return 0; 
    876675} 
    877676 
     
    14011200        } 
    14021201 
    1403         return rtl8366s_set_vlan(smi, val->port_vlan, member, untag, 0); 
     1202        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0); 
    14041203} 
    14051204 
     
    14071206{ 
    14081207        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1409         return rtl8366s_get_pvid(smi, port, val); 
     1208        return rtl8366_get_pvid(smi, port, val); 
    14101209} 
    14111210 
     
    14131212{ 
    14141213        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1415         return rtl8366s_set_pvid(smi, port, val); 
     1214        return rtl8366_set_pvid(smi, port, val); 
    14161215} 
    14171216 
     
    14291228                return err; 
    14301229 
    1431         return rtl8366s_reset_vlan(smi); 
     1230        return rtl8366_reset_vlan(smi); 
    14321231} 
    14331232 
Note: See TracChangeset for help on using the changeset viewer.