Changeset 22476


Ignore:
Timestamp:
2010-08-04T02:43:40+02:00 (6 years ago)
Author:
nbd
Message:

swconfig: cleanup of kernel drivers and interface

  • add some comments to a few data structures
  • add a switch_dev_ops data structure for attributes and callback to replace the stupid template memcpy
  • get rid of the switch_dev.priv pointer - using container_of() is better
Location:
trunk/target/linux/generic
Files:
4 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/files/drivers/net/phy/ar8216.c

    r21952 r22476  
    5353        u16 pvid[AR8216_NUM_PORTS]; 
    5454}; 
    55 static struct switch_dev athdev; 
    5655 
    5756#define to_ar8216(_dev) container_of(_dev, struct ar8216_priv, dev) 
     
    632631} 
    633632 
    634 static int 
    635 ar8216_config_init(struct phy_device *pdev) 
    636 { 
    637         struct ar8216_priv *priv; 
    638         struct net_device *dev = pdev->attached_dev; 
    639         int ret; 
    640  
    641         priv = kzalloc(sizeof(struct ar8216_priv), GFP_KERNEL); 
    642         if (priv == NULL) 
    643                 return -ENOMEM; 
    644  
    645         priv->phy = pdev; 
    646  
    647         priv->chip = ar8216_id_chip(priv); 
    648  
    649         if (pdev->addr == 0) 
    650                 printk(KERN_INFO "%s: AR%d switch driver attached.\n", 
    651                         pdev->attached_dev->name, priv->chip); 
    652  
    653  
    654         if (pdev->addr != 0) { 
    655                 if (priv->chip == AR8316) { 
    656                         pdev->supported |= SUPPORTED_1000baseT_Full; 
    657                         pdev->advertising |= ADVERTISED_1000baseT_Full; 
    658                 } 
    659                 kfree(priv); 
    660                 return 0; 
    661         } 
    662  
    663         pdev->supported = priv->chip == AR8316 ? 
    664                 SUPPORTED_1000baseT_Full : SUPPORTED_100baseT_Full; 
    665         pdev->advertising = pdev->supported; 
    666  
    667         mutex_init(&priv->reg_mutex); 
    668         priv->read = ar8216_mii_read; 
    669         priv->write = ar8216_mii_write; 
    670         memcpy(&priv->dev, &athdev, sizeof(struct switch_dev)); 
    671         pdev->priv = priv; 
    672  
    673         if (priv->chip == AR8316) { 
    674                 priv->dev.name = "Atheros AR8316"; 
    675                 priv->dev.vlans = AR8X16_MAX_VLANS; 
    676                 /* port 5 connected to the other mac, therefore unusable */ 
    677                 priv->dev.ports = (AR8216_NUM_PORTS - 1); 
    678         } 
    679  
    680         if ((ret = register_switch(&priv->dev, pdev->attached_dev)) < 0) { 
    681                 kfree(priv); 
    682                 goto done; 
    683         } 
    684  
    685         if (priv->chip == AR8316) { 
    686                 ret = ar8316_hw_init(priv); 
    687                 if (ret) { 
    688                         kfree(priv); 
    689                         goto done; 
    690                 } 
    691         } 
    692  
    693         ret = ar8216_reset_switch(&priv->dev); 
    694         if (ret) { 
    695                 kfree(priv); 
    696                 goto done; 
    697         } 
    698  
    699         dev->phy_ptr = priv; 
    700  
    701         /* VID fixup only needed on ar8216 */ 
    702         if (pdev->addr == 0 && priv->chip == AR8216) { 
    703                 pdev->pkt_align = 2; 
    704                 pdev->netif_receive_skb = ar8216_netif_receive_skb; 
    705                 pdev->netif_rx = ar8216_netif_rx; 
    706                 priv->ndo_old = dev->netdev_ops; 
    707                 memcpy(&priv->ndo, priv->ndo_old, sizeof(struct net_device_ops)); 
    708                 priv->ndo.ndo_start_xmit = ar8216_mangle_tx; 
    709                 dev->netdev_ops = &priv->ndo; 
    710         } 
    711  
    712 done: 
    713         return ret; 
    714 } 
    715  
    716 static int 
    717 ar8216_read_status(struct phy_device *phydev) 
    718 { 
    719         struct ar8216_priv *priv = phydev->priv; 
    720         int ret; 
    721         if (phydev->addr != 0) { 
    722                 return genphy_read_status(phydev); 
    723         } 
    724  
    725         phydev->speed = priv->chip == AR8316 ? SPEED_1000 : SPEED_100; 
    726         phydev->duplex = DUPLEX_FULL; 
    727         phydev->link = 1; 
    728  
    729         /* flush the address translation unit */ 
    730         mutex_lock(&priv->reg_mutex); 
    731         ret = ar8216_wait_bit(priv, AR8216_REG_ATU, AR8216_ATU_ACTIVE, 0); 
    732  
    733         if (!ret) 
    734                 priv->write(priv, AR8216_REG_ATU, AR8216_ATU_OP_FLUSH); 
    735         else 
    736                 ret = -ETIMEDOUT; 
    737         mutex_unlock(&priv->reg_mutex); 
    738  
    739         phydev->state = PHY_RUNNING; 
    740         netif_carrier_on(phydev->attached_dev); 
    741         phydev->adjust_link(phydev->attached_dev); 
    742  
    743         return ret; 
    744 } 
    745  
    746 static int 
    747 ar8216_config_aneg(struct phy_device *phydev) 
    748 { 
    749         if (phydev->addr == 0) 
    750                 return 0; 
    751  
    752         return genphy_config_aneg(phydev); 
    753 } 
    754  
    755 static int 
    756 ar8216_probe(struct phy_device *pdev) 
    757 { 
    758         struct ar8216_priv priv; 
    759         u16 chip; 
    760  
    761         priv.phy = pdev; 
    762         chip = ar8216_id_chip(&priv); 
    763         if (chip == UNKNOWN) 
    764                 return -ENODEV; 
    765  
    766         return 0; 
    767 } 
    768  
    769 static void 
    770 ar8216_remove(struct phy_device *pdev) 
    771 { 
    772         struct ar8216_priv *priv = pdev->priv; 
    773         struct net_device *dev = pdev->attached_dev; 
    774  
    775         if (!priv) 
    776                 return; 
    777  
    778         if (priv->ndo_old && dev) 
    779                 dev->netdev_ops = priv->ndo_old; 
    780         if (pdev->addr == 0) 
    781                 unregister_switch(&priv->dev); 
    782         kfree(priv); 
    783 } 
    784  
    785 /* template */ 
    786 static struct switch_dev athdev = { 
    787         .name = "Atheros AR8216", 
    788         .cpu_port = AR8216_PORT_CPU, 
    789         .ports = AR8216_NUM_PORTS, 
    790         .vlans = AR8216_NUM_VLANS, 
     633 
     634static const struct switch_dev_ops ar8216_ops = { 
    791635        .attr_global = { 
    792636                .attr = ar8216_globals, 
     
    809653}; 
    810654 
     655static int 
     656ar8216_config_init(struct phy_device *pdev) 
     657{ 
     658        struct ar8216_priv *priv; 
     659        struct net_device *dev = pdev->attached_dev; 
     660        struct switch_dev *swdev; 
     661        int ret; 
     662 
     663        priv = kzalloc(sizeof(struct ar8216_priv), GFP_KERNEL); 
     664        if (priv == NULL) 
     665                return -ENOMEM; 
     666 
     667        priv->phy = pdev; 
     668 
     669        priv->chip = ar8216_id_chip(priv); 
     670 
     671        if (pdev->addr == 0) 
     672                printk(KERN_INFO "%s: AR%d switch driver attached.\n", 
     673                        pdev->attached_dev->name, priv->chip); 
     674 
     675 
     676        if (pdev->addr != 0) { 
     677                if (priv->chip == AR8316) { 
     678                        pdev->supported |= SUPPORTED_1000baseT_Full; 
     679                        pdev->advertising |= ADVERTISED_1000baseT_Full; 
     680                } 
     681                kfree(priv); 
     682                return 0; 
     683        } 
     684 
     685        pdev->supported = priv->chip == AR8316 ? 
     686                SUPPORTED_1000baseT_Full : SUPPORTED_100baseT_Full; 
     687        pdev->advertising = pdev->supported; 
     688 
     689        mutex_init(&priv->reg_mutex); 
     690        priv->read = ar8216_mii_read; 
     691        priv->write = ar8216_mii_write; 
     692 
     693        pdev->priv = priv; 
     694 
     695        swdev = &priv->dev; 
     696        swdev->cpu_port = AR8216_PORT_CPU; 
     697        swdev->ops = &ar8216_ops; 
     698 
     699        if (priv->chip == AR8316) { 
     700                swdev->name = "Atheros AR8316"; 
     701                swdev->vlans = AR8X16_MAX_VLANS; 
     702                /* port 5 connected to the other mac, therefore unusable */ 
     703                swdev->ports = (AR8216_NUM_PORTS - 1); 
     704        } else { 
     705                swdev->name = "Atheros AR8216"; 
     706                swdev->vlans = AR8216_NUM_VLANS; 
     707                swdev->ports = AR8216_NUM_PORTS; 
     708        } 
     709 
     710        if ((ret = register_switch(&priv->dev, pdev->attached_dev)) < 0) { 
     711                kfree(priv); 
     712                goto done; 
     713        } 
     714 
     715        if (priv->chip == AR8316) { 
     716                ret = ar8316_hw_init(priv); 
     717                if (ret) { 
     718                        kfree(priv); 
     719                        goto done; 
     720                } 
     721        } 
     722 
     723        ret = ar8216_reset_switch(&priv->dev); 
     724        if (ret) { 
     725                kfree(priv); 
     726                goto done; 
     727        } 
     728 
     729        dev->phy_ptr = priv; 
     730 
     731        /* VID fixup only needed on ar8216 */ 
     732        if (pdev->addr == 0 && priv->chip == AR8216) { 
     733                pdev->pkt_align = 2; 
     734                pdev->netif_receive_skb = ar8216_netif_receive_skb; 
     735                pdev->netif_rx = ar8216_netif_rx; 
     736                priv->ndo_old = dev->netdev_ops; 
     737                memcpy(&priv->ndo, priv->ndo_old, sizeof(struct net_device_ops)); 
     738                priv->ndo.ndo_start_xmit = ar8216_mangle_tx; 
     739                dev->netdev_ops = &priv->ndo; 
     740        } 
     741 
     742done: 
     743        return ret; 
     744} 
     745 
     746static int 
     747ar8216_read_status(struct phy_device *phydev) 
     748{ 
     749        struct ar8216_priv *priv = phydev->priv; 
     750        int ret; 
     751        if (phydev->addr != 0) { 
     752                return genphy_read_status(phydev); 
     753        } 
     754 
     755        phydev->speed = priv->chip == AR8316 ? SPEED_1000 : SPEED_100; 
     756        phydev->duplex = DUPLEX_FULL; 
     757        phydev->link = 1; 
     758 
     759        /* flush the address translation unit */ 
     760        mutex_lock(&priv->reg_mutex); 
     761        ret = ar8216_wait_bit(priv, AR8216_REG_ATU, AR8216_ATU_ACTIVE, 0); 
     762 
     763        if (!ret) 
     764                priv->write(priv, AR8216_REG_ATU, AR8216_ATU_OP_FLUSH); 
     765        else 
     766                ret = -ETIMEDOUT; 
     767        mutex_unlock(&priv->reg_mutex); 
     768 
     769        phydev->state = PHY_RUNNING; 
     770        netif_carrier_on(phydev->attached_dev); 
     771        phydev->adjust_link(phydev->attached_dev); 
     772 
     773        return ret; 
     774} 
     775 
     776static int 
     777ar8216_config_aneg(struct phy_device *phydev) 
     778{ 
     779        if (phydev->addr == 0) 
     780                return 0; 
     781 
     782        return genphy_config_aneg(phydev); 
     783} 
     784 
     785static int 
     786ar8216_probe(struct phy_device *pdev) 
     787{ 
     788        struct ar8216_priv priv; 
     789        u16 chip; 
     790 
     791        priv.phy = pdev; 
     792        chip = ar8216_id_chip(&priv); 
     793        if (chip == UNKNOWN) 
     794                return -ENODEV; 
     795 
     796        return 0; 
     797} 
     798 
     799static void 
     800ar8216_remove(struct phy_device *pdev) 
     801{ 
     802        struct ar8216_priv *priv = pdev->priv; 
     803        struct net_device *dev = pdev->attached_dev; 
     804 
     805        if (!priv) 
     806                return; 
     807 
     808        if (priv->ndo_old && dev) 
     809                dev->netdev_ops = priv->ndo_old; 
     810        if (pdev->addr == 0) 
     811                unregister_switch(&priv->dev); 
     812        kfree(priv); 
     813} 
     814 
    811815static struct phy_driver ar8216_driver = { 
    812816        .phy_id         = 0x004d0000, 
  • trunk/target/linux/generic/files/drivers/net/phy/ip17xx.c

    r22468 r22476  
    324324}; 
    325325 
     326#define get_state(_dev) container_of((_dev), struct ip17xx_state, dev) 
    326327 
    327328static int ip_phy_read(struct ip17xx_state *state, int port, int reg) 
     
    735736static int ip17xx_get_enable_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    736737{ 
    737         struct ip17xx_state *state = dev->priv; 
     738        struct ip17xx_state *state = get_state(dev); 
    738739 
    739740        val->value.i = state->vlan_enabled; 
     
    757758static int ip17xx_set_enable_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    758759{ 
    759         struct ip17xx_state *state = dev->priv; 
     760        struct ip17xx_state *state = get_state(dev); 
    760761        int enable; 
    761762 
     
    775776static int ip17xx_get_ports(struct switch_dev *dev, struct switch_val *val) 
    776777{ 
    777         struct ip17xx_state *state = dev->priv; 
     778        struct ip17xx_state *state = get_state(dev); 
    778779        int b; 
    779780        int ind; 
     
    803804static int ip17xx_set_ports(struct switch_dev *dev, struct switch_val *val) 
    804805{ 
    805         struct ip17xx_state *state = dev->priv; 
     806        struct ip17xx_state *state = get_state(dev); 
    806807        int i; 
    807808 
     
    827828static int ip17xx_apply(struct switch_dev *dev) 
    828829{ 
    829         struct ip17xx_state *state = dev->priv; 
     830        struct ip17xx_state *state = get_state(dev); 
    830831 
    831832        if (REG_SUPP(state->regs->MII_REGISTER_EN)) { 
     
    842843static int ip17xx_reset(struct switch_dev *dev) 
    843844{ 
    844         struct ip17xx_state *state = dev->priv; 
     845        struct ip17xx_state *state = get_state(dev); 
    845846        int i, err; 
    846847 
     
    875876static int ip17xx_get_tagged(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    876877{ 
    877         struct ip17xx_state *state = dev->priv; 
     878        struct ip17xx_state *state = get_state(dev); 
    878879 
    879880        if (state->add_tag & (1<<val->port_vlan)) { 
     
    893894static int ip17xx_set_tagged(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    894895{ 
    895         struct ip17xx_state *state = dev->priv; 
     896        struct ip17xx_state *state = get_state(dev); 
    896897 
    897898        state->add_tag &= ~(1<<val->port_vlan); 
     
    909910static int ip17xx_get_phy(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    910911{ 
    911         struct ip17xx_state *state = dev->priv; 
     912        struct ip17xx_state *state = get_state(dev); 
    912913 
    913914        val->value.i = state->proc_mii.p; 
     
    918919static int ip17xx_set_phy(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    919920{ 
    920         struct ip17xx_state *state = dev->priv; 
     921        struct ip17xx_state *state = get_state(dev); 
    921922        int new_reg = val->value.i; 
    922923 
     
    931932static int ip17xx_get_reg(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    932933{ 
    933         struct ip17xx_state *state = dev->priv; 
     934        struct ip17xx_state *state = get_state(dev); 
    934935 
    935936        val->value.i = state->proc_mii.m; 
     
    940941static int ip17xx_set_reg(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    941942{ 
    942         struct ip17xx_state *state = dev->priv; 
     943        struct ip17xx_state *state = get_state(dev); 
    943944        int new_reg = val->value.i; 
    944945 
     
    953954static int ip17xx_get_val(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    954955{ 
    955         struct ip17xx_state *state = dev->priv; 
     956        struct ip17xx_state *state = get_state(dev); 
    956957        int retval = -EINVAL; 
    957958        if (REG_SUPP(state->proc_mii)) 
     
    969970static int ip17xx_set_val(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    970971{ 
    971         struct ip17xx_state *state = dev->priv; 
     972        struct ip17xx_state *state = get_state(dev); 
    972973        int myval, err = -EINVAL; 
    973974 
     
    981982static int ip17xx_read_name(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    982983{ 
    983         struct ip17xx_state *state = dev->priv; 
     984        struct ip17xx_state *state = get_state(dev); 
    984985        val->value.s = state->regs->NAME; // Just a const pointer, won't be freed by swconfig. 
    985986        return 0; 
     
    988989static int ip17xx_get_tag(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    989990{ 
    990         struct ip17xx_state *state = dev->priv; 
     991        struct ip17xx_state *state = get_state(dev); 
    991992        int vlan = val->port_vlan; 
    992993 
     
    10001001static int ip17xx_set_tag(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    10011002{ 
    1002         struct ip17xx_state *state = dev->priv; 
     1003        struct ip17xx_state *state = get_state(dev); 
    10031004        int vlan = val->port_vlan; 
    10041005        int tag = val->value.i; 
     
    10161017static int ip17xx_set_port_speed(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    10171018{ 
    1018         struct ip17xx_state *state = dev->priv; 
     1019        struct ip17xx_state *state = get_state(dev); 
    10191020        int nr = val->port_vlan; 
    10201021        int ctrl; 
     
    10531054static int ip17xx_get_port_speed(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    10541055{ 
    1055         struct ip17xx_state *state = dev->priv; 
     1056        struct ip17xx_state *state = get_state(dev); 
    10561057        int nr = val->port_vlan; 
    10571058        int speed, status; 
     
    10801081static int ip17xx_get_port_status(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val) 
    10811082{ 
    1082         struct ip17xx_state *state = dev->priv; 
     1083        struct ip17xx_state *state = get_state(dev); 
    10831084        int ctrl, speed, status; 
    10841085        int nr = val->port_vlan; 
     
    11241125static int ip17xx_get_pvid(struct switch_dev *dev, int port, int *val) 
    11251126{ 
    1126         struct ip17xx_state *state = dev->priv; 
     1127        struct ip17xx_state *state = get_state(dev); 
    11271128 
    11281129        *val = state->ports[port].pvid; 
     
    11321133static int ip17xx_set_pvid(struct switch_dev *dev, int port, int val) 
    11331134{ 
    1134         struct ip17xx_state *state = dev->priv; 
     1135        struct ip17xx_state *state = get_state(dev); 
    11351136 
    11361137        if (val < 0 || val >= MAX_VLANS) 
     
    12441245}; 
    12451246 
     1247static const struct switch_dev_ops ip17xx_ops = { 
     1248        .attr_global = { 
     1249                .attr = ip17xx_global, 
     1250                .n_attr = ARRAY_SIZE(ip17xx_global), 
     1251        }, 
     1252        .attr_port = { 
     1253                .attr = ip17xx_port, 
     1254                .n_attr = ARRAY_SIZE(ip17xx_port), 
     1255        }, 
     1256        .attr_vlan = { 
     1257                .attr = ip17xx_vlan, 
     1258                .n_attr = ARRAY_SIZE(ip17xx_vlan), 
     1259        }, 
     1260 
     1261        .get_port_pvid = ip17xx_get_pvid, 
     1262        .set_port_pvid = ip17xx_set_pvid, 
     1263        .get_vlan_ports = ip17xx_get_ports, 
     1264        .set_vlan_ports = ip17xx_set_ports, 
     1265        .apply_config = ip17xx_apply, 
     1266        .reset_switch = ip17xx_reset, 
     1267}; 
     1268 
    12461269static int ip17xx_probe(struct phy_device *pdev) 
    12471270{ 
     
    12591282 
    12601283        dev = &state->dev; 
    1261         dev->attr_global.attr = ip17xx_global; 
    1262         dev->attr_global.n_attr = ARRAY_SIZE(ip17xx_global); 
    1263         dev->attr_port.attr = ip17xx_port; 
    1264         dev->attr_port.n_attr = ARRAY_SIZE(ip17xx_port); 
    1265         dev->attr_vlan.attr = ip17xx_vlan; 
    1266         dev->attr_vlan.n_attr = ARRAY_SIZE(ip17xx_vlan); 
    1267  
    1268         dev->get_port_pvid = ip17xx_get_pvid; 
    1269         dev->set_port_pvid = ip17xx_set_pvid; 
    1270         dev->get_vlan_ports = ip17xx_get_ports; 
    1271         dev->set_vlan_ports = ip17xx_set_ports; 
    1272         dev->apply_config = ip17xx_apply; 
    1273         dev->reset_switch = ip17xx_reset; 
    1274  
    1275         dev->priv = state; 
     1284 
    12761285        pdev->priv = state; 
    12771286        state->mii_bus = pdev->bus; 
     
    12851294        dev->ports = state->regs->NUM_PORTS; 
    12861295        dev->name = state->regs->NAME; 
     1296        dev->ops = &ip17xx_ops; 
    12871297 
    12881298        pr_info("IP17xx: Found %s at %s\n", dev->name, dev_name(&pdev->dev)); 
  • trunk/target/linux/generic/files/drivers/net/phy/rtl8306.c

    r21952 r22476  
    251251 
    252252 
    253 /* IFXMIPS compat stuff - remove after PHY layer migration */ 
    254 static struct switch_dev rtldev; 
    255 /* END IFXMIPS compat stuff */ 
    256  
    257  
    258253static inline void 
    259254rtl_set_page(struct rtl_priv *priv, unsigned int page) 
     
    707702} 
    708703 
     704static struct switch_attr rtl_globals[] = { 
     705        { 
     706                .type = SWITCH_TYPE_INT, 
     707                .name = "reset", 
     708                .description = "Reset the switch", 
     709                .set = rtl_reset, 
     710        }, 
     711        { 
     712                .type = SWITCH_TYPE_INT, 
     713                .name = "enable_vlan", 
     714                .description = "Enable VLAN mode", 
     715                .max = 1, 
     716                .set = rtl_set_vlan, 
     717                .get = rtl_get_vlan, 
     718        }, 
     719        { 
     720                RTL_GLOBAL_REGATTR(EN_TRUNK), 
     721                .name = "trunk", 
     722                .description = "Enable port trunking", 
     723                .max = 1, 
     724        }, 
     725        { 
     726                RTL_GLOBAL_REGATTR(TRUNK_PORTSEL), 
     727                .name = "trunk_sel", 
     728                .description = "Select ports for trunking (0: 0,1 - 1: 3,4)", 
     729                .max = 1, 
     730        }, 
     731#ifdef DEBUG 
     732        { 
     733                RTL_GLOBAL_REGATTR(VLAN_FILTER), 
     734                .name = "vlan_filter", 
     735                .description = "Filter incoming packets for allowed VLANS", 
     736                .max = 1, 
     737        }, 
     738        { 
     739                .type = SWITCH_TYPE_INT, 
     740                .name = "cpuport", 
     741                .description = "CPU Port", 
     742                .set = rtl_set_cpuport, 
     743                .get = rtl_get_cpuport, 
     744                .max = RTL8306_NUM_PORTS, 
     745        }, 
     746        { 
     747                .type = SWITCH_TYPE_INT, 
     748                .name = "use_cpuport", 
     749                .description = "CPU Port handling flag", 
     750                .set = rtl_set_use_cpuport, 
     751                .get = rtl_get_use_cpuport, 
     752                .max = RTL8306_NUM_PORTS, 
     753        }, 
     754        { 
     755                RTL_GLOBAL_REGATTR(TRAP_CPU), 
     756                .name = "trap_cpu", 
     757                .description = "VLAN trap to CPU", 
     758                .max = 1, 
     759        }, 
     760        { 
     761                RTL_GLOBAL_REGATTR(VLAN_TAG_AWARE), 
     762                .name = "vlan_tag_aware", 
     763                .description = "Enable VLAN tag awareness", 
     764                .max = 1, 
     765        }, 
     766        { 
     767                RTL_GLOBAL_REGATTR(VLAN_TAG_ONLY), 
     768                .name = "tag_only", 
     769                .description = "Only accept tagged packets", 
     770                .max = 1, 
     771        }, 
     772#endif 
     773}; 
     774static struct switch_attr rtl_port[] = { 
     775        { 
     776                RTL_PORT_REGATTR(PVID), 
     777                .name = "pvid", 
     778                .description = "Port VLAN ID", 
     779                .max = RTL8306_NUM_VLANS - 1, 
     780        }, 
     781        { 
     782                RTL_PORT_REGATTR(LINK), 
     783                .name = "link", 
     784                .description = "get the current link state", 
     785                .max = 1, 
     786                .set = NULL, 
     787        }, 
     788#ifdef DEBUG 
     789        { 
     790                RTL_PORT_REGATTR(NULL_VID_REPLACE), 
     791                .name = "null_vid", 
     792                .description = "NULL VID gets replaced by port default vid", 
     793                .max = 1, 
     794        }, 
     795        { 
     796                RTL_PORT_REGATTR(NON_PVID_DISCARD), 
     797                .name = "non_pvid_discard", 
     798                .description = "discard packets with VID != PVID", 
     799                .max = 1, 
     800        }, 
     801        { 
     802                RTL_PORT_REGATTR(VID_INSERT), 
     803                .name = "vid_insert_remove", 
     804                .description = "how should the switch insert and remove vids ?", 
     805                .max = 3, 
     806        }, 
     807        { 
     808                RTL_PORT_REGATTR(TAG_INSERT), 
     809                .name = "tag_insert", 
     810                .description = "tag insertion handling", 
     811                .max = 3, 
     812        }, 
     813#endif 
     814        { 
     815                RTL_PORT_REGATTR(SPEED), 
     816                .name = "speed", 
     817                .description = "current link speed", 
     818                .max = 1, 
     819        }, 
     820        { 
     821                RTL_PORT_REGATTR(NWAY), 
     822                .name = "nway", 
     823                .description = "enable autonegotiation", 
     824                .max = 1, 
     825        }, 
     826}; 
     827 
     828static struct switch_attr rtl_vlan[] = { 
     829        { 
     830                RTL_VLAN_REGATTR(VID), 
     831                .name = "vid", 
     832                .description = "VLAN ID", 
     833                .max = 4095, 
     834        }, 
     835}; 
     836 
     837static const struct switch_dev_ops rtl8306_ops = { 
     838        .attr_global = { 
     839                .attr = rtl_globals, 
     840                .n_attr = ARRAY_SIZE(rtl_globals), 
     841        }, 
     842        .attr_port = { 
     843                .attr = rtl_port, 
     844                .n_attr = ARRAY_SIZE(rtl_port), 
     845        }, 
     846        .attr_vlan = { 
     847                .attr = rtl_vlan, 
     848                .n_attr = ARRAY_SIZE(rtl_vlan), 
     849        }, 
     850 
     851        .get_vlan_ports = rtl_get_ports, 
     852        .set_vlan_ports = rtl_set_ports, 
     853        .apply_config = rtl_hw_apply, 
     854}; 
     855 
    709856static int 
    710857rtl8306_config_init(struct phy_device *pdev) 
     
    722869 
    723870        val.value.i = 1; 
    724         memcpy(&priv->dev, &rtldev, sizeof(struct switch_dev)); 
     871        priv->dev.cpu_port = RTL8306_PORT_CPU; 
     872        priv->dev.ports = RTL8306_NUM_PORTS; 
     873        priv->dev.vlans = RTL8306_NUM_VLANS; 
     874        priv->dev.ops = &rtl8306_ops; 
    725875        priv->do_cpu = 0; 
    726876        priv->page = -1; 
    727877        priv->bus = pdev->bus; 
    728  
    729         dev->priv = priv; 
    730878 
    731879        chipid = rtl_get(dev, RTL_REG_CHIPID); 
     
    765913} 
    766914 
    767 static struct switch_attr rtl_globals[] = { 
    768         { 
    769                 .type = SWITCH_TYPE_INT, 
    770                 .name = "reset", 
    771                 .description = "Reset the switch", 
    772                 .set = rtl_reset, 
    773         }, 
    774         { 
    775                 .type = SWITCH_TYPE_INT, 
    776                 .name = "enable_vlan", 
    777                 .description = "Enable VLAN mode", 
    778                 .max = 1, 
    779                 .set = rtl_set_vlan, 
    780                 .get = rtl_get_vlan, 
    781         }, 
    782         { 
    783                 RTL_GLOBAL_REGATTR(EN_TRUNK), 
    784                 .name = "trunk", 
    785                 .description = "Enable port trunking", 
    786                 .max = 1, 
    787         }, 
    788         { 
    789                 RTL_GLOBAL_REGATTR(TRUNK_PORTSEL), 
    790                 .name = "trunk_sel", 
    791                 .description = "Select ports for trunking (0: 0,1 - 1: 3,4)", 
    792                 .max = 1, 
    793         }, 
    794 #ifdef DEBUG 
    795         { 
    796                 RTL_GLOBAL_REGATTR(VLAN_FILTER), 
    797                 .name = "vlan_filter", 
    798                 .description = "Filter incoming packets for allowed VLANS", 
    799                 .max = 1, 
    800         }, 
    801         { 
    802                 .type = SWITCH_TYPE_INT, 
    803                 .name = "cpuport", 
    804                 .description = "CPU Port", 
    805                 .set = rtl_set_cpuport, 
    806                 .get = rtl_get_cpuport, 
    807                 .max = RTL8306_NUM_PORTS, 
    808         }, 
    809         { 
    810                 .type = SWITCH_TYPE_INT, 
    811                 .name = "use_cpuport", 
    812                 .description = "CPU Port handling flag", 
    813                 .set = rtl_set_use_cpuport, 
    814                 .get = rtl_get_use_cpuport, 
    815                 .max = RTL8306_NUM_PORTS, 
    816         }, 
    817         { 
    818                 RTL_GLOBAL_REGATTR(TRAP_CPU), 
    819                 .name = "trap_cpu", 
    820                 .description = "VLAN trap to CPU", 
    821                 .max = 1, 
    822         }, 
    823         { 
    824                 RTL_GLOBAL_REGATTR(VLAN_TAG_AWARE), 
    825                 .name = "vlan_tag_aware", 
    826                 .description = "Enable VLAN tag awareness", 
    827                 .max = 1, 
    828         }, 
    829         { 
    830                 RTL_GLOBAL_REGATTR(VLAN_TAG_ONLY), 
    831                 .name = "tag_only", 
    832                 .description = "Only accept tagged packets", 
    833                 .max = 1, 
    834         }, 
    835 #endif 
    836 }; 
    837 static struct switch_attr rtl_port[] = { 
    838         { 
    839                 RTL_PORT_REGATTR(PVID), 
    840                 .name = "pvid", 
    841                 .description = "Port VLAN ID", 
    842                 .max = RTL8306_NUM_VLANS - 1, 
    843         }, 
    844         { 
    845                 RTL_PORT_REGATTR(LINK), 
    846                 .name = "link", 
    847                 .description = "get the current link state", 
    848                 .max = 1, 
    849                 .set = NULL, 
    850         }, 
    851 #ifdef DEBUG 
    852         { 
    853                 RTL_PORT_REGATTR(NULL_VID_REPLACE), 
    854                 .name = "null_vid", 
    855                 .description = "NULL VID gets replaced by port default vid", 
    856                 .max = 1, 
    857         }, 
    858         { 
    859                 RTL_PORT_REGATTR(NON_PVID_DISCARD), 
    860                 .name = "non_pvid_discard", 
    861                 .description = "discard packets with VID != PVID", 
    862                 .max = 1, 
    863         }, 
    864         { 
    865                 RTL_PORT_REGATTR(VID_INSERT), 
    866                 .name = "vid_insert_remove", 
    867                 .description = "how should the switch insert and remove vids ?", 
    868                 .max = 3, 
    869         }, 
    870         { 
    871                 RTL_PORT_REGATTR(TAG_INSERT), 
    872                 .name = "tag_insert", 
    873                 .description = "tag insertion handling", 
    874                 .max = 3, 
    875         }, 
    876 #endif 
    877         { 
    878                 RTL_PORT_REGATTR(SPEED), 
    879                 .name = "speed", 
    880                 .description = "current link speed", 
    881                 .max = 1, 
    882         }, 
    883         { 
    884                 RTL_PORT_REGATTR(NWAY), 
    885                 .name = "nway", 
    886                 .description = "enable autonegotiation", 
    887                 .max = 1, 
    888         }, 
    889 }; 
    890  
    891 static struct switch_attr rtl_vlan[] = { 
    892         { 
    893                 RTL_VLAN_REGATTR(VID), 
    894                 .name = "vid", 
    895                 .description = "VLAN ID", 
    896                 .max = 4095, 
    897         }, 
    898 }; 
    899  
    900 /* template */ 
    901 static struct switch_dev rtldev = { 
    902         .cpu_port = RTL8306_PORT_CPU, 
    903         .ports = RTL8306_NUM_PORTS, 
    904         .vlans = RTL8306_NUM_VLANS, 
    905         .attr_global = { 
    906                 .attr = rtl_globals, 
    907                 .n_attr = ARRAY_SIZE(rtl_globals), 
    908         }, 
    909         .attr_port = { 
    910                 .attr = rtl_port, 
    911                 .n_attr = ARRAY_SIZE(rtl_port), 
    912         }, 
    913         .attr_vlan = { 
    914                 .attr = rtl_vlan, 
    915                 .n_attr = ARRAY_SIZE(rtl_vlan), 
    916         }, 
    917  
    918         .get_vlan_ports = rtl_get_ports, 
    919         .set_vlan_ports = rtl_set_ports, 
    920         .apply_config = rtl_hw_apply, 
    921 }; 
    922  
    923915 
    924916static int 
  • trunk/target/linux/generic/files/drivers/net/phy/rtl8366rb.c

    r22204 r22476  
    850850}; 
    851851 
    852 /* template */ 
    853 static struct switch_dev rtl8366_switch_dev = { 
    854         .name = "RTL8366S", 
    855         .cpu_port = RTL8366RB_PORT_NUM_CPU, 
    856         .ports = RTL8366RB_NUM_PORTS, 
    857         .vlans = RTL8366RB_NUM_VLANS, 
     852static const struct switch_dev_ops rtl8366_ops = { 
    858853        .attr_global = { 
    859854                .attr = rtl8366rb_globals, 
     
    881876        int err; 
    882877 
    883         memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev)); 
    884         dev->priv = smi; 
     878        dev->name = "RTL8366RB"; 
     879        dev->cpu_port = RTL8366RB_PORT_NUM_CPU; 
     880        dev->ports = RTL8366RB_NUM_PORTS; 
     881        dev->vlans = RTL8366RB_NUM_VLANS; 
     882        dev->ops = &rtl8366_ops; 
    885883        dev->devname = dev_name(smi->parent); 
    886884 
  • trunk/target/linux/generic/files/drivers/net/phy/rtl8366s.c

    r22204 r22476  
    877877}; 
    878878 
    879 /* template */ 
    880 static struct switch_dev rtl8366_switch_dev = { 
    881         .name = "RTL8366S", 
    882         .cpu_port = RTL8366S_PORT_NUM_CPU, 
    883         .ports = RTL8366S_NUM_PORTS, 
    884         .vlans = RTL8366S_NUM_VLANS, 
     879static const struct switch_dev_ops rtl8366_ops = { 
    885880        .attr_global = { 
    886881                .attr = rtl8366s_globals, 
     
    908903        int err; 
    909904 
    910         memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev)); 
    911         dev->priv = smi; 
     905        dev->name = "RTL8366S"; 
     906        dev->cpu_port = RTL8366S_PORT_NUM_CPU; 
     907        dev->ports = RTL8366S_NUM_PORTS; 
     908        dev->vlans = RTL8366S_NUM_VLANS; 
     909        dev->ops = &rtl8366_ops; 
    912910        dev->devname = dev_name(smi->parent); 
    913911 
  • trunk/target/linux/generic/files/drivers/net/phy/swconfig.c

    r21952 r22476  
    6666                return -EINVAL; 
    6767 
    68         if (!dev->get_vlan_ports) 
     68        if (!dev->ops->get_vlan_ports) 
    6969                return -EOPNOTSUPP; 
    7070 
    71         ret = dev->get_vlan_ports(dev, val); 
     71        ret = dev->ops->get_vlan_ports(dev, val); 
    7272        return ret; 
    7373} 
     
    7777{ 
    7878        struct switch_port *ports = val->value.ports; 
     79        const struct switch_dev_ops *ops = dev->ops; 
    7980        int i; 
    8081 
     
    8687                return -EINVAL; 
    8788 
    88         if (!dev->set_vlan_ports) 
     89        if (!ops->set_vlan_ports) 
    8990                return -EOPNOTSUPP; 
    9091 
     
    9394                        return -EINVAL; 
    9495 
    95                 if (dev->set_port_pvid && !(ports[i].flags & (1 << SWITCH_PORT_FLAG_TAGGED))) 
    96                         dev->set_port_pvid(dev, ports[i].id, val->port_vlan); 
    97         } 
    98  
    99         return dev->set_vlan_ports(dev, val); 
     96                if (ops->set_port_pvid && 
     97                    !(ports[i].flags & (1 << SWITCH_PORT_FLAG_TAGGED))) 
     98                        ops->set_port_pvid(dev, ports[i].id, val->port_vlan); 
     99        } 
     100 
     101        return ops->set_vlan_ports(dev, val); 
    100102} 
    101103 
     
    106108                return -EINVAL; 
    107109 
    108         if (!dev->set_port_pvid) 
     110        if (!dev->ops->set_port_pvid) 
    109111                return -EOPNOTSUPP; 
    110112 
    111         return dev->set_port_pvid(dev, val->port_vlan, val->value.i); 
     113        return dev->ops->set_port_pvid(dev, val->port_vlan, val->value.i); 
    112114} 
    113115 
     
    118120                return -EINVAL; 
    119121 
    120         if (!dev->get_port_pvid) 
     122        if (!dev->ops->get_port_pvid) 
    121123                return -EOPNOTSUPP; 
    122124 
    123         return dev->get_port_pvid(dev, val->port_vlan, &val->value.i); 
     125        return dev->ops->get_port_pvid(dev, val->port_vlan, &val->value.i); 
    124126} 
    125127 
     
    128130{ 
    129131        /* don't complain if not supported by the switch driver */ 
    130         if (!dev->apply_config) 
     132        if (!dev->ops->apply_config) 
    131133                return 0; 
    132134 
    133         return dev->apply_config(dev); 
     135        return dev->ops->apply_config(dev); 
    134136} 
    135137 
     
    138140{ 
    139141        /* don't complain if not supported by the switch driver */ 
    140         if (!dev->reset_switch) 
     142        if (!dev->ops->reset_switch) 
    141143                return 0; 
    142144 
    143         return dev->reset_switch(dev); 
     145        return dev->ops->reset_switch(dev); 
    144146} 
    145147 
     
    195197static void swconfig_defaults_init(struct switch_dev *dev) 
    196198{ 
     199        const struct switch_dev_ops *ops = dev->ops; 
     200 
    197201        dev->def_global = 0; 
    198202        dev->def_vlan = 0; 
    199203        dev->def_port = 0; 
    200204 
    201         if (dev->get_vlan_ports || dev->set_vlan_ports) 
     205        if (ops->get_vlan_ports || ops->set_vlan_ports) 
    202206                set_bit(VLAN_PORTS, &dev->def_vlan); 
    203207 
    204         if (dev->get_port_pvid || dev->set_port_pvid) 
     208        if (ops->get_port_pvid || ops->set_port_pvid) 
    205209                set_bit(PORT_PVID, &dev->def_port); 
    206210 
     
    336340                                goto error; 
    337341                } 
    338                 err = genlmsg_unicast(cb->msg, info->snd_pid); 
     342                err = genlmsg_reply(cb->msg, info); 
    339343                cb->msg = NULL; 
    340344                if (err < 0) 
     
    372376        switch(hdr->cmd) { 
    373377        case SWITCH_CMD_LIST_GLOBAL: 
    374                 alist = &dev->attr_global; 
     378                alist = &dev->ops->attr_global; 
    375379                def_list = default_global; 
    376380                def_active = &dev->def_global; 
     
    378382                break; 
    379383        case SWITCH_CMD_LIST_VLAN: 
    380                 alist = &dev->attr_vlan; 
     384                alist = &dev->ops->attr_vlan; 
    381385                def_list = default_vlan; 
    382386                def_active = &dev->def_vlan; 
     
    384388                break; 
    385389        case SWITCH_CMD_LIST_PORT: 
    386                 alist = &dev->attr_port; 
     390                alist = &dev->ops->attr_port; 
    387391                def_list = default_port; 
    388392                def_active = &dev->def_port; 
     
    420424                return 0; 
    421425 
    422         return genlmsg_unicast(cb.msg, info->snd_pid); 
     426        return genlmsg_reply(cb.msg, info); 
    423427 
    424428error: 
     
    450454        case SWITCH_CMD_SET_GLOBAL: 
    451455        case SWITCH_CMD_GET_GLOBAL: 
    452                 alist = &dev->attr_global; 
     456                alist = &dev->ops->attr_global; 
    453457                def_list = default_global; 
    454458                def_active = &dev->def_global; 
     
    457461        case SWITCH_CMD_SET_VLAN: 
    458462        case SWITCH_CMD_GET_VLAN: 
    459                 alist = &dev->attr_vlan; 
     463                alist = &dev->ops->attr_vlan; 
    460464                def_list = default_vlan; 
    461465                def_active = &dev->def_vlan; 
     
    469473        case SWITCH_CMD_SET_PORT: 
    470474        case SWITCH_CMD_GET_PORT: 
    471                 alist = &dev->attr_port; 
     475                alist = &dev->ops->attr_port; 
    472476                def_list = default_port; 
    473477                def_active = &dev->def_port; 
     
    733737 
    734738        swconfig_put_dev(dev); 
    735         return genlmsg_unicast(msg, info->snd_pid); 
     739        return genlmsg_reply(msg, info); 
    736740 
    737741nla_put_failure: 
  • trunk/target/linux/generic/files/include/linux/switch.h

    r21952 r22476  
    103103void unregister_switch(struct switch_dev *dev); 
    104104 
     105/** 
     106 * struct switch_attrlist - attribute list 
     107 * 
     108 * @n_attr: number of attributes 
     109 * @attr: pointer to the attributes array 
     110 */ 
    105111struct switch_attrlist { 
    106         /* filled in by the driver */ 
    107112        int n_attr; 
    108113        const struct switch_attr *attr; 
    109114}; 
    110115 
     116/** 
     117 * struct switch_dev_ops - switch driver operations 
     118 * 
     119 * @attr_global: global switch attribute list 
     120 * @attr_port: port attribute list 
     121 * @attr_vlan: vlan attribute list 
     122 * 
     123 * Callbacks: 
     124 * 
     125 * @get_vlan_ports: read the port list of a VLAN 
     126 * @set_vlan_ports: set the port list of a VLAN 
     127 * 
     128 * @get_port_pvid: get the primary VLAN ID of a port 
     129 * @set_port_pvid: set the primary VLAN ID of a port 
     130 * 
     131 * @apply_config: apply all changed settings to the switch 
     132 * @reset_switch: resetting the switch 
     133 */ 
     134struct switch_dev_ops { 
     135        struct switch_attrlist attr_global, attr_port, attr_vlan; 
     136 
     137        int (*get_vlan_ports)(struct switch_dev *dev, struct switch_val *val); 
     138        int (*set_vlan_ports)(struct switch_dev *dev, struct switch_val *val); 
     139 
     140        int (*get_port_pvid)(struct switch_dev *dev, int port, int *val); 
     141        int (*set_port_pvid)(struct switch_dev *dev, int port, int val); 
     142 
     143        int (*apply_config)(struct switch_dev *dev); 
     144        int (*reset_switch)(struct switch_dev *dev); 
     145}; 
    111146 
    112147struct switch_dev { 
    113         int id; 
    114         void *priv; 
     148        const struct switch_dev_ops *ops; 
    115149        const char *name; 
    116150 
     
    122156        int vlans; 
    123157        int cpu_port; 
    124         struct switch_attrlist attr_global, attr_port, attr_vlan; 
     158 
     159        /* the following fields are internal for swconfig */ 
     160        int id; 
     161        struct list_head dev_list; 
     162        unsigned long def_global, def_port, def_vlan; 
    125163 
    126164        spinlock_t lock; 
    127165        struct switch_port *portbuf; 
    128         struct list_head dev_list; 
    129         unsigned long def_global, def_port, def_vlan; 
    130  
    131         int (*get_vlan_ports)(struct switch_dev *dev, struct switch_val *val); 
    132         int (*set_vlan_ports)(struct switch_dev *dev, struct switch_val *val); 
    133         int (*get_port_pvid)(struct switch_dev *dev, int port, int *val); 
    134         int (*set_port_pvid)(struct switch_dev *dev, int port, int val); 
    135         int (*apply_config)(struct switch_dev *dev); 
    136         int (*reset_switch)(struct switch_dev *dev); 
    137166}; 
    138167 
Note: See TracChangeset for help on using the changeset viewer.