Changeset 22677 for branches/backfire


Ignore:
Timestamp:
2010-08-16T21:23:53+02:00 (6 years ago)
Author:
nbd
Message:

merge swconfig (+drivers) improvements from trunk

Location:
branches/backfire/target/linux
Files:
1 added
2 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/target/linux/atheros/config-2.6.30

    r20202 r22677  
    8383CONFIG_HW_RANDOM=y 
    8484CONFIG_INITRAMFS_SOURCE="" 
    85 CONFIG_IP175C_PHY=y 
     85CONFIG_IP17XX_PHY=y 
    8686CONFIG_IRQ_CPU=y 
    8787# CONFIG_LEDS_GPIO is not set 
  • branches/backfire/target/linux/atheros/config-2.6.32

    r20202 r22677  
    8585CONFIG_HW_RANDOM=y 
    8686CONFIG_INITRAMFS_SOURCE="" 
    87 CONFIG_IP175C_PHY=y 
     87CONFIG_IP17XX_PHY=y 
    8888CONFIG_IRQ_CPU=y 
    8989# CONFIG_LEDS_GPIO is not set 
  • branches/backfire/target/linux/generic-2.6/config-2.6.30

    r22333 r22677  
    871871CONFIG_IOSCHED_NOOP=y 
    872872# CONFIG_IP1000 is not set 
    873 # CONFIG_IP175C_PHY is not set 
     873# CONFIG_IP17XX_PHY is not set 
    874874# CONFIG_IP6_NF_FILTER is not set 
    875875# CONFIG_IP6_NF_IPTABLES is not set 
  • branches/backfire/target/linux/generic-2.6/config-2.6.32

    r22333 r22677  
    922922CONFIG_IOSCHED_NOOP=y 
    923923# CONFIG_IP1000 is not set 
    924 # CONFIG_IP175C_PHY is not set 
     924# CONFIG_IP17XX_PHY is not set 
    925925# CONFIG_IP6_NF_FILTER is not set 
    926926# CONFIG_IP6_NF_IPTABLES is not set 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/ar8216.c

    r20774 r22677  
    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, 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8306.c

    r18709 r22677  
    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 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.c

    r22030 r22677  
    308308} 
    309309 
    310 int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag, 
    311                     u32 fid) 
     310static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, 
     311                            u32 untag, u32 fid) 
    312312{ 
    313313        struct rtl8366_vlan_4k vlan4k; 
     
    348348        return err; 
    349349} 
    350 EXPORT_SYMBOL_GPL(rtl8366_set_vlan); 
     350 
     351static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val) 
     352{ 
     353        struct rtl8366_vlan_mc vlanmc; 
     354        int err; 
     355        int index; 
     356 
     357        err = smi->ops->get_mc_index(smi, port, &index); 
     358        if (err) 
     359                return err; 
     360 
     361        err = smi->ops->get_vlan_mc(smi, index, &vlanmc); 
     362        if (err) 
     363                return err; 
     364 
     365        *val = vlanmc.vid; 
     366        return 0; 
     367} 
     368 
     369static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, 
     370                            unsigned vid) 
     371{ 
     372        struct rtl8366_vlan_mc vlanmc; 
     373        struct rtl8366_vlan_4k vlan4k; 
     374        int err; 
     375        int i; 
     376 
     377        /* Try to find an existing MC entry for this VID */ 
     378        for (i = 0; i < smi->num_vlan_mc; i++) { 
     379                err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     380                if (err) 
     381                        return err; 
     382 
     383                if (vid == vlanmc.vid) { 
     384                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     385                        if (err) 
     386                                return err; 
     387 
     388                        err = smi->ops->set_mc_index(smi, port, i); 
     389                        return err; 
     390                } 
     391        } 
     392 
     393        /* We have no MC entry for this VID, try to find an empty one */ 
     394        for (i = 0; i < smi->num_vlan_mc; i++) { 
     395                err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
     396                if (err) 
     397                        return err; 
     398 
     399                if (vlanmc.vid == 0 && vlanmc.member == 0) { 
     400                        /* Update the entry from the 4K table */ 
     401                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
     402                        if (err) 
     403                                return err; 
     404 
     405                        vlanmc.vid = vid; 
     406                        vlanmc.member = vlan4k.member; 
     407                        vlanmc.untag = vlan4k.untag; 
     408                        vlanmc.fid = vlan4k.fid; 
     409                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     410                        if (err) 
     411                                return err; 
     412 
     413                        err = smi->ops->set_mc_index(smi, port, i); 
     414                        return err; 
     415                } 
     416        } 
     417 
     418        /* MC table is full, try to find an unused entry and replace it */ 
     419        for (i = 0; i < smi->num_vlan_mc; i++) { 
     420                int used; 
     421 
     422                err = rtl8366_mc_is_used(smi, i, &used); 
     423                if (err) 
     424                        return err; 
     425 
     426                if (!used) { 
     427                        /* Update the entry from the 4K table */ 
     428                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
     429                        if (err) 
     430                                return err; 
     431 
     432                        vlanmc.vid = vid; 
     433                        vlanmc.member = vlan4k.member; 
     434                        vlanmc.untag = vlan4k.untag; 
     435                        vlanmc.fid = vlan4k.fid; 
     436                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
     437                        if (err) 
     438                                return err; 
     439 
     440                        err = smi->ops->set_mc_index(smi, port, i); 
     441                        return err; 
     442                } 
     443        } 
     444 
     445        dev_err(smi->parent, 
     446                "all VLAN member configurations are in use\n"); 
     447 
     448        return -ENOSPC; 
     449} 
    351450 
    352451int rtl8366_reset_vlan(struct rtl8366_smi *smi) 
     
    388487EXPORT_SYMBOL_GPL(rtl8366_reset_vlan); 
    389488 
    390 int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val) 
    391 { 
    392         struct rtl8366_vlan_mc vlanmc; 
    393         int err; 
    394         int index; 
    395  
    396         err = smi->ops->get_mc_index(smi, port, &index); 
    397         if (err) 
    398                 return err; 
    399  
    400         err = smi->ops->get_vlan_mc(smi, index, &vlanmc); 
    401         if (err) 
    402                 return err; 
    403  
    404         *val = vlanmc.vid; 
    405         return 0; 
    406 } 
    407 EXPORT_SYMBOL_GPL(rtl8366_get_pvid); 
    408  
    409 int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid) 
    410 { 
    411         struct rtl8366_vlan_mc vlanmc; 
    412         struct rtl8366_vlan_4k vlan4k; 
    413         int err; 
    414         int i; 
    415  
    416         /* Try to find an existing MC entry for this VID */ 
    417         for (i = 0; i < smi->num_vlan_mc; i++) { 
    418                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    419                 if (err) 
    420                         return err; 
    421  
    422                 if (vid == vlanmc.vid) { 
    423                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    424                         if (err) 
    425                                 return err; 
    426  
    427                         err = smi->ops->set_mc_index(smi, port, i); 
    428                         return err; 
    429                 } 
    430         } 
    431  
    432         /* We have no MC entry for this VID, try to find an empty one */ 
    433         for (i = 0; i < smi->num_vlan_mc; i++) { 
    434                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc); 
    435                 if (err) 
    436                         return err; 
    437  
    438                 if (vlanmc.vid == 0 && vlanmc.member == 0) { 
    439                         /* Update the entry from the 4K table */ 
    440                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    441                         if (err) 
    442                                 return err; 
    443  
    444                         vlanmc.vid = vid; 
    445                         vlanmc.member = vlan4k.member; 
    446                         vlanmc.untag = vlan4k.untag; 
    447                         vlanmc.fid = vlan4k.fid; 
    448                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    449                         if (err) 
    450                                 return err; 
    451  
    452                         err = smi->ops->set_mc_index(smi, port, i); 
    453                         return err; 
    454                 } 
    455         } 
    456  
    457         /* MC table is full, try to find an unused entry and replace it */ 
    458         for (i = 0; i < smi->num_vlan_mc; i++) { 
    459                 int used; 
    460  
    461                 err = rtl8366_mc_is_used(smi, i, &used); 
    462                 if (err) 
    463                         return err; 
    464  
    465                 if (!used) { 
    466                         /* Update the entry from the 4K table */ 
    467                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k); 
    468                         if (err) 
    469                                 return err; 
    470  
    471                         vlanmc.vid = vid; 
    472                         vlanmc.member = vlan4k.member; 
    473                         vlanmc.untag = vlan4k.untag; 
    474                         vlanmc.fid = vlan4k.fid; 
    475                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc); 
    476                         if (err) 
    477                                 return err; 
    478  
    479                         err = smi->ops->set_mc_index(smi, port, i); 
    480                         return err; 
    481                 } 
    482         } 
    483  
    484         dev_err(smi->parent, 
    485                 "all VLAN member configurations are in use\n"); 
    486  
    487         return -ENOSPC; 
    488 } 
    489 EXPORT_SYMBOL_GPL(rtl8366_set_pvid); 
    490  
    491489#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
    492490int rtl8366_debugfs_open(struct inode *inode, struct file *file) 
     
    518516                                i, vlanmc.vid, vlanmc.priority, 
    519517                                vlanmc.member, vlanmc.untag, vlanmc.fid); 
     518        } 
     519 
     520        return simple_read_from_buffer(user_buf, count, ppos, buf, len); 
     521} 
     522 
     523static ssize_t rtl8366_read_debugfs_pvid(struct file *file, 
     524                                         char __user *user_buf, 
     525                                         size_t count, loff_t *ppos) 
     526{ 
     527        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data; 
     528        char *buf = smi->buf; 
     529        int len = 0; 
     530        int i; 
     531 
     532        len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n", 
     533                        "port", "pvid"); 
     534 
     535        for (i = 0; i < smi->num_ports; i++) { 
     536                int pvid; 
     537                int err; 
     538 
     539                err = rtl8366_get_pvid(smi, i, &pvid); 
     540                if (err) 
     541                        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     542                                "%4d error\n", i); 
     543                else 
     544                        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     545                                "%4d %4d\n", i, pvid); 
    520546        } 
    521547 
     
    637663}; 
    638664 
     665static const struct file_operations fops_rtl8366_pvid = { 
     666        .read   = rtl8366_read_debugfs_pvid, 
     667        .open   = rtl8366_debugfs_open, 
     668        .owner  = THIS_MODULE 
     669}; 
     670 
    639671static const struct file_operations fops_rtl8366_mibs = { 
    640672        .read = rtl8366_read_debugfs_mibs, 
     
    679711                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
    680712                        "vlan_mc"); 
     713                return; 
     714        } 
     715 
     716        node = debugfs_create_file("pvid", S_IRUSR, root, smi, 
     717                                   &fops_rtl8366_pvid); 
     718        if (!node) { 
     719                dev_err(smi->parent, "Creating debugfs file '%s' failed\n", 
     720                        "pvid"); 
    681721                return; 
    682722        } 
     
    742782} 
    743783 
     784int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val) 
     785{ 
     786        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     787        return rtl8366_get_pvid(smi, port, val); 
     788} 
     789EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid); 
     790 
     791int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val) 
     792{ 
     793        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     794        return rtl8366_set_pvid(smi, port, val); 
     795} 
     796EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid); 
     797 
     798int rtl8366_sw_get_port_mib(struct switch_dev *dev, 
     799                            const struct switch_attr *attr, 
     800                            struct switch_val *val) 
     801{ 
     802        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     803        int i, len = 0; 
     804        unsigned long long counter = 0; 
     805        char *buf = smi->buf; 
     806 
     807        if (val->port_vlan >= smi->num_ports) 
     808                return -EINVAL; 
     809 
     810        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     811                        "Port %d MIB counters\n", 
     812                        val->port_vlan); 
     813 
     814        for (i = 0; i < smi->num_mib_counters; ++i) { 
     815                len += snprintf(buf + len, sizeof(smi->buf) - len, 
     816                                "%-36s: ", smi->mib_counters[i].name); 
     817                if (!smi->ops->get_mib_counter(smi, i, val->port_vlan, 
     818                                               &counter)) 
     819                        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     820                                        "%llu\n", counter); 
     821                else 
     822                        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     823                                        "%s\n", "error"); 
     824        } 
     825 
     826        val->value.s = buf; 
     827        val->len = len; 
     828        return 0; 
     829} 
     830EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib); 
     831 
     832int rtl8366_sw_get_vlan_info(struct switch_dev *dev, 
     833                             const struct switch_attr *attr, 
     834                             struct switch_val *val) 
     835{ 
     836        int i; 
     837        u32 len = 0; 
     838        struct rtl8366_vlan_4k vlan4k; 
     839        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     840        char *buf = smi->buf; 
     841        int err; 
     842 
     843        if (!smi->ops->is_vlan_valid(smi, val->port_vlan)) 
     844                return -EINVAL; 
     845 
     846        memset(buf, '\0', sizeof(smi->buf)); 
     847 
     848        err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k); 
     849        if (err) 
     850                return err; 
     851 
     852        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     853                        "VLAN %d: Ports: '", vlan4k.vid); 
     854 
     855        for (i = 0; i < smi->num_ports; i++) { 
     856                if (!(vlan4k.member & (1 << i))) 
     857                        continue; 
     858 
     859                len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i, 
     860                                (vlan4k.untag & (1 << i)) ? "" : "t"); 
     861        } 
     862 
     863        len += snprintf(buf + len, sizeof(smi->buf) - len, 
     864                        "', members=%04x, untag=%04x, fid=%u", 
     865                        vlan4k.member, vlan4k.untag, vlan4k.fid); 
     866 
     867        val->value.s = buf; 
     868        val->len = len; 
     869 
     870        return 0; 
     871} 
     872EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info); 
     873 
     874int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val) 
     875{ 
     876        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     877        struct switch_port *port; 
     878        struct rtl8366_vlan_4k vlan4k; 
     879        int i; 
     880 
     881        if (!smi->ops->is_vlan_valid(smi, val->port_vlan)) 
     882                return -EINVAL; 
     883 
     884        smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k); 
     885 
     886        port = &val->value.ports[0]; 
     887        val->len = 0; 
     888        for (i = 0; i < smi->num_ports; i++) { 
     889                if (!(vlan4k.member & BIT(i))) 
     890                        continue; 
     891 
     892                port->id = i; 
     893                port->flags = (vlan4k.untag & BIT(i)) ? 
     894                                        0 : BIT(SWITCH_PORT_FLAG_TAGGED); 
     895                val->len++; 
     896                port++; 
     897        } 
     898        return 0; 
     899} 
     900EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports); 
     901 
     902int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val) 
     903{ 
     904        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
     905        struct switch_port *port; 
     906        u32 member = 0; 
     907        u32 untag = 0; 
     908        int i; 
     909 
     910        if (!smi->ops->is_vlan_valid(smi, val->port_vlan)) 
     911                return -EINVAL; 
     912 
     913        port = &val->value.ports[0]; 
     914        for (i = 0; i < val->len; i++, port++) { 
     915                member |= BIT(port->id); 
     916 
     917                if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED))) 
     918                        untag |= BIT(port->id); 
     919        } 
     920 
     921        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0); 
     922} 
     923EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports); 
     924 
     925struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent) 
     926{ 
     927        struct rtl8366_smi *smi; 
     928 
     929        BUG_ON(!parent); 
     930 
     931        smi = kzalloc(sizeof(*smi), GFP_KERNEL); 
     932        if (!smi) { 
     933                dev_err(parent, "no memory for private data\n"); 
     934                return NULL; 
     935        } 
     936 
     937        smi->parent = parent; 
     938        return smi; 
     939} 
     940EXPORT_SYMBOL_GPL(rtl8366_smi_alloc); 
     941 
    744942int rtl8366_smi_init(struct rtl8366_smi *smi) 
    745943{ 
    746944        int err; 
    747  
    748         if (!smi->parent) 
    749                 return -EINVAL; 
    750945 
    751946        if (!smi->ops) 
     
    774969        if (err) { 
    775970                dev_err(smi->parent, "chip detection failed, err=%d\n", err); 
     971                goto err_free_sck; 
     972        } 
     973 
     974        err = smi->ops->setup(smi); 
     975        if (err) { 
     976                dev_err(smi->parent, "chip setup failed, err=%d\n", err); 
    776977                goto err_free_sck; 
    777978        } 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.h

    r22029 r22677  
    1313 
    1414#include <linux/phy.h> 
     15#include <linux/switch.h> 
    1516 
    1617struct rtl8366_smi_ops; 
     
    3536        struct mii_bus          *mii_bus; 
    3637        int                     mii_irq[PHY_MAX_ADDR]; 
     38        struct switch_dev       sw_dev; 
    3739 
    3840        unsigned int            cpu_port; 
     
    6870struct rtl8366_smi_ops { 
    6971        int     (*detect)(struct rtl8366_smi *smi); 
     72        int     (*setup)(struct rtl8366_smi *smi); 
    7073 
    7174        int     (*mii_read)(struct mii_bus *bus, int addr, int reg); 
     
    8487        int     (*get_mib_counter)(struct rtl8366_smi *smi, int counter, 
    8588                                   int port, unsigned long long *val); 
     89        int     (*is_vlan_valid)(struct rtl8366_smi *smi, unsigned vlan); 
    8690}; 
    8791 
     92struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent); 
    8893int rtl8366_smi_init(struct rtl8366_smi *smi); 
    8994void rtl8366_smi_cleanup(struct rtl8366_smi *smi); 
     
    9297int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data); 
    9398 
    94 int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag, 
    95                      u32 fid); 
    9699int rtl8366_reset_vlan(struct rtl8366_smi *smi); 
    97 int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val); 
    98 int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid); 
    99100 
    100101#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS 
     
    102103#endif 
    103104 
     105static inline struct rtl8366_smi *sw_to_rtl8366_smi(struct switch_dev *sw) 
     106{ 
     107        return container_of(sw, struct rtl8366_smi, sw_dev); 
     108} 
     109 
     110int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val); 
     111int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val); 
     112int rtl8366_sw_get_port_mib(struct switch_dev *dev, 
     113                            const struct switch_attr *attr, 
     114                            struct switch_val *val); 
     115int rtl8366_sw_get_vlan_info(struct switch_dev *dev, 
     116                             const struct switch_attr *attr, 
     117                             struct switch_val *val); 
     118int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val); 
     119int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val); 
     120 
    104121#endif /*  _RTL8366_SMI_H */ 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c

    r22657 r22677  
    1616#include <linux/delay.h> 
    1717#include <linux/skbuff.h> 
    18 #include <linux/switch.h> 
    1918#include <linux/rtl8366rb.h> 
    2019 
     
    108107#define RTL8366RB_TABLE_VLAN_WRITE_CTRL         0x0F01 
    109108 
    110 #define RTL8366RB_VLAN_MEMCONF_BASE             0x0020 
     109#define RTL8366RB_VLAN_MC_BASE(_x)              (0x0020 + (_x) * 3) 
    111110 
    112111 
     
    157156#define RTL8366RB_PORT_ALL_INTERNAL      RTL8366RB_PORT_CPU 
    158157 
    159 struct rtl8366rb { 
    160         struct device           *parent; 
    161         struct rtl8366_smi      smi; 
    162         struct switch_dev       dev; 
    163 }; 
    164  
    165 struct rtl8366rb_vlan_mc { 
    166         u16     reserved2:1; 
    167         u16     priority:3; 
    168         u16     vid:12; 
    169         u16     untag:8; 
    170         u16     member:8; 
    171         u16     stag_mbr:8; 
    172         u16     stag_idx:3; 
    173         u16     reserved1:2; 
    174         u16     fid:3; 
    175 }; 
    176  
    177 struct rtl8366rb_vlan_4k { 
    178         u16     reserved1:4; 
    179         u16     vid:12; 
    180         u16     untag:8; 
    181         u16     member:8; 
    182         u16     reserved2:13; 
    183         u16     fid:3; 
    184 }; 
     158#define RTL8366RB_VLAN_VID_MASK         0xfff 
     159#define RTL8366RB_VLAN_PRIORITY_SHIFT   12 
     160#define RTL8366RB_VLAN_PRIORITY_MASK    0x7 
     161#define RTL8366RB_VLAN_UNTAG_SHIFT      8 
     162#define RTL8366RB_VLAN_UNTAG_MASK       0xff 
     163#define RTL8366RB_VLAN_MEMBER_MASK      0xff 
     164#define RTL8366RB_VLAN_FID_MASK         0x7 
    185165 
    186166static struct rtl8366_mib_counter rtl8366rb_mib_counters[] = { 
     
    234214        } while (0) 
    235215 
    236 static inline struct rtl8366rb *smi_to_rtl8366rb(struct rtl8366_smi *smi) 
    237 { 
    238         return container_of(smi, struct rtl8366rb, smi); 
    239 } 
    240  
    241 static inline struct rtl8366rb *sw_to_rtl8366rb(struct switch_dev *sw) 
    242 { 
    243         return container_of(sw, struct rtl8366rb, dev); 
    244 } 
    245  
    246 static inline struct rtl8366_smi *sw_to_rtl8366_smi(struct switch_dev *sw) 
    247 { 
    248         struct rtl8366rb *rtl = sw_to_rtl8366rb(sw); 
    249         return &rtl->smi; 
    250 } 
    251  
    252216static int rtl8366rb_reset_chip(struct rtl8366_smi *smi) 
    253217{ 
     
    420384                                 struct rtl8366_vlan_4k *vlan4k) 
    421385{ 
    422         struct rtl8366rb_vlan_4k vlan4k_priv; 
     386        u32 data[3]; 
    423387        int err; 
    424         u32 data; 
    425         u16 *tableaddr; 
     388        int i; 
    426389 
    427390        memset(vlan4k, '\0', sizeof(struct rtl8366_vlan_4k)); 
    428         vlan4k_priv.vid = vid; 
    429391 
    430392        if (vid >= RTL8366RB_NUM_VIDS) 
    431393                return -EINVAL; 
    432394 
    433         tableaddr = (u16 *)&vlan4k_priv; 
    434  
    435395        /* write VID */ 
    436         data = *tableaddr; 
    437         err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE, data); 
     396        err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE, 
     397                                    vid & RTL8366RB_VLAN_VID_MASK); 
    438398        if (err) 
    439399                return err; 
     
    445405                return err; 
    446406 
    447         err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE, &data); 
    448         if (err) 
    449                 return err; 
    450  
    451         *tableaddr = data; 
    452         tableaddr++; 
    453  
    454         err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE + 1, 
    455                                    &data); 
    456         if (err) 
    457                 return err; 
    458  
    459         *tableaddr = data; 
    460         tableaddr++; 
    461  
    462         err = rtl8366_smi_read_reg(smi, RTL8366RB_VLAN_TABLE_READ_BASE + 2, 
    463                                    &data); 
    464         if (err) 
    465                 return err; 
    466         *tableaddr = data; 
     407        for (i = 0; i < 3; i++) { 
     408                err = rtl8366_smi_read_reg(smi, 
     409                                           RTL8366RB_VLAN_TABLE_READ_BASE + i, 
     410                                           &data[i]); 
     411                if (err) 
     412                        return err; 
     413        } 
    467414 
    468415        vlan4k->vid = vid; 
    469         vlan4k->untag = vlan4k_priv.untag; 
    470         vlan4k->member = vlan4k_priv.member; 
    471         vlan4k->fid = vlan4k_priv.fid; 
     416        vlan4k->untag = (data[1] >> RTL8366RB_VLAN_UNTAG_SHIFT) & 
     417                        RTL8366RB_VLAN_UNTAG_MASK; 
     418        vlan4k->member = data[1] & RTL8366RB_VLAN_MEMBER_MASK; 
     419        vlan4k->fid = data[2] & RTL8366RB_VLAN_FID_MASK; 
    472420 
    473421        return 0; 
     
    477425                                 const struct rtl8366_vlan_4k *vlan4k) 
    478426{ 
    479         struct rtl8366rb_vlan_4k vlan4k_priv; 
     427        u32 data[3]; 
    480428        int err; 
    481         u32 data; 
    482         u16 *tableaddr; 
     429        int i; 
    483430 
    484431        if (vlan4k->vid >= RTL8366RB_NUM_VIDS || 
     
    488435                return -EINVAL; 
    489436 
    490         vlan4k_priv.vid = vlan4k->vid; 
    491         vlan4k_priv.untag = vlan4k->untag; 
    492         vlan4k_priv.member = vlan4k->member; 
    493         vlan4k_priv.fid = vlan4k->fid; 
    494  
    495         tableaddr = (u16 *)&vlan4k_priv; 
    496  
    497         data = *tableaddr; 
    498  
    499         err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE, data); 
    500         if (err) 
    501                 return err; 
    502  
    503         tableaddr++; 
    504  
    505         data = *tableaddr; 
    506  
    507         err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE + 1, 
    508                                     data); 
    509         if (err) 
    510                 return err; 
    511  
    512         tableaddr++; 
    513  
    514         data = *tableaddr; 
    515  
    516         err = rtl8366_smi_write_reg(smi, RTL8366RB_VLAN_TABLE_WRITE_BASE + 2, 
    517                                     data); 
    518         if (err) 
    519                 return err; 
     437        data[0] = vlan4k->vid & RTL8366RB_VLAN_VID_MASK; 
     438        data[1] = (vlan4k->member & RTL8366RB_VLAN_MEMBER_MASK) | 
     439                  ((vlan4k->untag & RTL8366RB_VLAN_UNTAG_MASK) << 
     440                        RTL8366RB_VLAN_UNTAG_SHIFT); 
     441        data[2] = vlan4k->fid & RTL8366RB_VLAN_FID_MASK; 
     442 
     443        for (i = 0; i < 3; i++) { 
     444                err = rtl8366_smi_write_reg(smi, 
     445                                            RTL8366RB_VLAN_TABLE_WRITE_BASE + i, 
     446                                            data[i]); 
     447                if (err) 
     448                        return err; 
     449        } 
    520450 
    521451        /* write table access control word */ 
     
    529459                                 struct rtl8366_vlan_mc *vlanmc) 
    530460{ 
    531         struct rtl8366rb_vlan_mc vlanmc_priv; 
     461        u32 data[3]; 
    532462        int err; 
    533         u32 addr; 
    534         u32 data; 
    535         u16 *tableaddr; 
     463        int i; 
    536464 
    537465        memset(vlanmc, '\0', sizeof(struct rtl8366_vlan_mc)); 
     
    540468                return -EINVAL; 
    541469 
    542         tableaddr = (u16 *)&vlanmc_priv; 
    543  
    544         addr = RTL8366RB_VLAN_MEMCONF_BASE + (index * 3); 
    545         err = rtl8366_smi_read_reg(smi, addr, &data); 
    546         if (err) 
    547                 return err; 
    548  
    549         *tableaddr = data; 
    550         tableaddr++; 
    551  
    552         addr = RTL8366RB_VLAN_MEMCONF_BASE + 1 + (index * 3); 
    553         err = rtl8366_smi_read_reg(smi, addr, &data); 
    554         if (err) 
    555                 return err; 
    556  
    557         *tableaddr = data; 
    558         tableaddr++; 
    559  
    560         addr = RTL8366RB_VLAN_MEMCONF_BASE + 2 + (index * 3); 
    561         err = rtl8366_smi_read_reg(smi, addr, &data); 
    562         if (err) 
    563                 return err; 
    564  
    565         *tableaddr = data; 
    566  
    567         vlanmc->vid = vlanmc_priv.vid; 
    568         vlanmc->priority = vlanmc_priv.priority; 
    569         vlanmc->untag = vlanmc_priv.untag; 
    570         vlanmc->member = vlanmc_priv.member; 
    571         vlanmc->fid = vlanmc_priv.fid; 
     470        for (i = 0; i < 3; i++) { 
     471                err = rtl8366_smi_read_reg(smi, 
     472                                           RTL8366RB_VLAN_MC_BASE(index) + i, 
     473                                           &data[i]); 
     474                if (err) 
     475                        return err; 
     476        } 
     477 
     478        vlanmc->vid = data[0] & RTL8366RB_VLAN_VID_MASK; 
     479        vlanmc->priority = (data[0] >> RTL8366RB_VLAN_PRIORITY_SHIFT) & 
     480                           RTL8366RB_VLAN_PRIORITY_MASK; 
     481        vlanmc->untag = (data[1] >> RTL8366RB_VLAN_UNTAG_SHIFT) & 
     482                        RTL8366RB_VLAN_UNTAG_MASK; 
     483        vlanmc->member = data[1] & RTL8366RB_VLAN_MEMBER_MASK; 
     484        vlanmc->fid = data[2] & RTL8366RB_VLAN_FID_MASK; 
    572485 
    573486        return 0; 
     
    577490                                 const struct rtl8366_vlan_mc *vlanmc) 
    578491{ 
    579         struct rtl8366rb_vlan_mc vlanmc_priv; 
     492        u32 data[3]; 
    580493        int err; 
    581         u32 addr; 
    582         u32 data; 
    583         u16 *tableaddr; 
     494        int i; 
    584495 
    585496        if (index >= RTL8366RB_NUM_VLANS || 
     
    591502                return -EINVAL; 
    592503 
    593         vlanmc_priv.vid = vlanmc->vid; 
    594         vlanmc_priv.priority = vlanmc->priority; 
    595         vlanmc_priv.untag = vlanmc->untag; 
    596         vlanmc_priv.member = vlanmc->member; 
    597         vlanmc_priv.stag_mbr = 0; 
    598         vlanmc_priv.stag_idx = 0; 
    599         vlanmc_priv.fid = vlanmc->fid; 
    600  
    601         addr = RTL8366RB_VLAN_MEMCONF_BASE + (index * 3); 
    602  
    603         tableaddr = (u16 *)&vlanmc_priv; 
    604         data = *tableaddr; 
    605  
    606         err = rtl8366_smi_write_reg(smi, addr, data); 
    607         if (err) 
    608                 return err; 
    609  
    610         addr = RTL8366RB_VLAN_MEMCONF_BASE + 1 + (index * 3); 
    611  
    612         tableaddr++; 
    613         data = *tableaddr; 
    614  
    615         err = rtl8366_smi_write_reg(smi, addr, data); 
    616         if (err) 
    617                 return err; 
    618  
    619         addr = RTL8366RB_VLAN_MEMCONF_BASE + 2 + (index * 3); 
    620  
    621         tableaddr++; 
    622         data = *tableaddr; 
    623  
    624         err = rtl8366_smi_write_reg(smi, addr, data); 
    625         if (err) 
    626                 return err; 
     504        data[0] = (vlanmc->vid & RTL8366RB_VLAN_VID_MASK) | 
     505                  ((vlanmc->priority & RTL8366RB_VLAN_PRIORITY_MASK) << 
     506                        RTL8366RB_VLAN_PRIORITY_SHIFT); 
     507        data[1] = (vlanmc->member & RTL8366RB_VLAN_MEMBER_MASK) | 
     508                  ((vlanmc->untag & RTL8366RB_VLAN_UNTAG_MASK) << 
     509                        RTL8366RB_VLAN_UNTAG_SHIFT); 
     510        data[2] = vlanmc->fid & RTL8366RB_VLAN_FID_MASK; 
     511 
     512        for (i = 0; i < 3; i++) { 
     513                err = rtl8366_smi_write_reg(smi, 
     514                                            RTL8366RB_VLAN_MC_BASE(index) + i, 
     515                                            data[i]); 
     516                if (err) 
     517                        return err; 
     518        } 
     519 
    627520        return 0; 
    628521} 
     
    660553} 
    661554 
     555static int rtl8366rb_is_vlan_valid(struct rtl8366_smi *smi, unsigned vlan) 
     556{ 
     557        if (vlan == 0 || vlan >= RTL8366RB_NUM_VLANS) 
     558                return 0; 
     559 
     560        return 1; 
     561} 
     562 
    662563static int rtl8366rb_vlan_set_vlan(struct rtl8366_smi *smi, int enable) 
    663564{ 
     
    678579{ 
    679580        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    680         int err = 0; 
    681  
    682         if (val->value.i == 1) 
    683                 err = rtl8366_smi_rmwr(smi, RTL8366RB_MIB_CTRL_REG, 0, 
    684                                        RTL8366RB_MIB_CTRL_GLOBAL_RESET); 
    685  
    686         return err; 
     581 
     582        return rtl8366_smi_rmwr(smi, RTL8366RB_MIB_CTRL_REG, 0, 
     583                                RTL8366RB_MIB_CTRL_GLOBAL_RESET); 
    687584} 
    688585 
     
    844741} 
    845742 
    846 static int rtl8366rb_sw_get_vlan_info(struct switch_dev *dev, 
    847                                      const struct switch_attr *attr, 
    848                                      struct switch_val *val) 
    849 { 
    850         int i; 
    851         u32 len = 0; 
    852         struct rtl8366_vlan_4k vlan4k; 
    853         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    854         char *buf = smi->buf; 
    855         int err; 
    856  
    857         if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    858                 return -EINVAL; 
    859  
    860         memset(buf, '\0', sizeof(smi->buf)); 
    861  
    862         err = rtl8366rb_get_vlan_4k(smi, val->port_vlan, &vlan4k); 
    863         if (err) 
    864                 return err; 
    865  
    866         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    867                         "VLAN %d: Ports: '", vlan4k.vid); 
    868  
    869         for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
    870                 if (!(vlan4k.member & (1 << i))) 
    871                         continue; 
    872  
    873                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i, 
    874                                 (vlan4k.untag & (1 << i)) ? "" : "t"); 
    875         } 
    876  
    877         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    878                         "', members=%04x, untag=%04x, fid=%u", 
    879                         vlan4k.member, vlan4k.untag, vlan4k.fid); 
    880  
    881         val->value.s = buf; 
    882         val->len = len; 
    883  
    884         return 0; 
    885 } 
    886  
    887743static int rtl8366rb_sw_set_port_led(struct switch_dev *dev, 
    888744                                    const struct switch_attr *attr, 
     
    937793        return rtl8366_smi_rmwr(smi, RTL8366RB_MIB_CTRL_REG, 0, 
    938794                                RTL8366RB_MIB_CTRL_PORT_RESET(val->port_vlan)); 
    939 } 
    940  
    941 static int rtl8366rb_sw_get_port_mib(struct switch_dev *dev, 
    942                                     const struct switch_attr *attr, 
    943                                     struct switch_val *val) 
    944 { 
    945         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    946         int i, len = 0; 
    947         unsigned long long counter = 0; 
    948         char *buf = smi->buf; 
    949  
    950         if (val->port_vlan >= RTL8366RB_NUM_PORTS) 
    951                 return -EINVAL; 
    952  
    953         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    954                         "Port %d MIB counters\n", 
    955                         val->port_vlan); 
    956  
    957         for (i = 0; i < ARRAY_SIZE(rtl8366rb_mib_counters); ++i) { 
    958                 len += snprintf(buf + len, sizeof(smi->buf) - len, 
    959                                 "%-36s: ", rtl8366rb_mib_counters[i].name); 
    960                 if (!rtl8366rb_get_mib_counter(smi, i, val->port_vlan, &counter)) 
    961                         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    962                                         "%llu\n", counter); 
    963                 else 
    964                         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    965                                         "%s\n", "error"); 
    966         } 
    967  
    968         val->value.s = buf; 
    969         val->len = len; 
    970         return 0; 
    971 } 
    972  
    973 static int rtl8366rb_sw_get_vlan_ports(struct switch_dev *dev, 
    974                                       struct switch_val *val) 
    975 { 
    976         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    977         struct switch_port *port; 
    978         struct rtl8366_vlan_4k vlan4k; 
    979         int i; 
    980  
    981         if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    982                 return -EINVAL; 
    983  
    984         rtl8366rb_get_vlan_4k(smi, val->port_vlan, &vlan4k); 
    985  
    986         port = &val->value.ports[0]; 
    987         val->len = 0; 
    988         for (i = 0; i < RTL8366RB_NUM_PORTS; i++) { 
    989                 if (!(vlan4k.member & BIT(i))) 
    990                         continue; 
    991  
    992                 port->id = i; 
    993                 port->flags = (vlan4k.untag & BIT(i)) ? 
    994                                         0 : BIT(SWITCH_PORT_FLAG_TAGGED); 
    995                 val->len++; 
    996                 port++; 
    997         } 
    998         return 0; 
    999 } 
    1000  
    1001 static int rtl8366rb_sw_set_vlan_ports(struct switch_dev *dev, 
    1002                                       struct switch_val *val) 
    1003 { 
    1004         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1005         struct switch_port *port; 
    1006         u32 member = 0; 
    1007         u32 untag = 0; 
    1008         int i; 
    1009  
    1010         if (val->port_vlan == 0 || val->port_vlan >= RTL8366RB_NUM_VLANS) 
    1011                 return -EINVAL; 
    1012  
    1013         port = &val->value.ports[0]; 
    1014         for (i = 0; i < val->len; i++, port++) { 
    1015                 member |= BIT(port->id); 
    1016  
    1017                 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED))) 
    1018                         untag |= BIT(port->id); 
    1019         } 
    1020  
    1021         return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0); 
    1022 } 
    1023  
    1024 static int rtl8366rb_sw_get_port_pvid(struct switch_dev *dev, int port, int *val) 
    1025 { 
    1026         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1027         return rtl8366_get_pvid(smi, port, val); 
    1028 } 
    1029  
    1030 static int rtl8366rb_sw_set_port_pvid(struct switch_dev *dev, int port, int val) 
    1031 { 
    1032         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1033         return rtl8366_set_pvid(smi, port, val); 
    1034795} 
    1035796 
     
    1075836                .ofs = 2 
    1076837        }, { 
    1077                 .type = SWITCH_TYPE_INT, 
     838                .type = SWITCH_TYPE_NOVAL, 
    1078839                .name = "reset_mibs", 
    1079840                .description = "Reset all MIB counters", 
    1080841                .set = rtl8366rb_sw_reset_mibs, 
    1081                 .get = NULL, 
    1082                 .max = 1 
    1083842        }, { 
    1084843                .type = SWITCH_TYPE_INT, 
     
    1101860                .get = rtl8366rb_sw_get_port_link, 
    1102861        }, { 
    1103                 .type = SWITCH_TYPE_INT, 
     862                .type = SWITCH_TYPE_NOVAL, 
    1104863                .name = "reset_mib", 
    1105864                .description = "Reset single port MIB counters", 
    1106                 .max = 1, 
    1107865                .set = rtl8366rb_sw_reset_port_mibs, 
    1108                 .get = NULL, 
    1109866        }, { 
    1110867                .type = SWITCH_TYPE_STRING, 
     
    1113870                .max = 33, 
    1114871                .set = NULL, 
    1115                 .get = rtl8366rb_sw_get_port_mib, 
     872                .get = rtl8366_sw_get_port_mib, 
    1116873        }, { 
    1117874                .type = SWITCH_TYPE_INT, 
     
    1131888                .max = 1, 
    1132889                .set = NULL, 
    1133                 .get = rtl8366rb_sw_get_vlan_info, 
     890                .get = rtl8366_sw_get_vlan_info, 
    1134891        }, 
    1135892}; 
    1136893 
    1137 /* template */ 
    1138 static struct switch_dev rtl8366_switch_dev = { 
    1139         .name = "RTL8366S", 
    1140         .cpu_port = RTL8366RB_PORT_NUM_CPU, 
    1141         .ports = RTL8366RB_NUM_PORTS, 
    1142         .vlans = RTL8366RB_NUM_VLANS, 
     894static const struct switch_dev_ops rtl8366_ops = { 
    1143895        .attr_global = { 
    1144896                .attr = rtl8366rb_globals, 
     
    1154906        }, 
    1155907 
    1156         .get_vlan_ports = rtl8366rb_sw_get_vlan_ports, 
    1157         .set_vlan_ports = rtl8366rb_sw_set_vlan_ports, 
    1158         .get_port_pvid = rtl8366rb_sw_get_port_pvid, 
    1159         .set_port_pvid = rtl8366rb_sw_set_port_pvid, 
     908        .get_vlan_ports = rtl8366_sw_get_vlan_ports, 
     909        .set_vlan_ports = rtl8366_sw_set_vlan_ports, 
     910        .get_port_pvid = rtl8366_sw_get_port_pvid, 
     911        .set_port_pvid = rtl8366_sw_set_port_pvid, 
    1160912        .reset_switch = rtl8366rb_sw_reset_switch, 
    1161913}; 
    1162914 
    1163 static int rtl8366rb_switch_init(struct rtl8366rb *rtl) 
    1164 { 
    1165         struct switch_dev *dev = &rtl->dev; 
     915static int rtl8366rb_switch_init(struct rtl8366_smi *smi) 
     916{ 
     917        struct switch_dev *dev = &smi->sw_dev; 
    1166918        int err; 
    1167919 
    1168         memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev)); 
    1169         dev->priv = rtl; 
    1170         dev->devname = dev_name(rtl->parent); 
     920        dev->name = "RTL8366RB"; 
     921        dev->cpu_port = RTL8366RB_PORT_NUM_CPU; 
     922        dev->ports = RTL8366RB_NUM_PORTS; 
     923        dev->vlans = RTL8366RB_NUM_VLANS; 
     924        dev->ops = &rtl8366_ops; 
     925        dev->devname = dev_name(smi->parent); 
    1171926 
    1172927        err = register_switch(dev, NULL); 
    1173928        if (err) 
    1174                 dev_err(rtl->parent, "switch registration failed\n"); 
     929                dev_err(smi->parent, "switch registration failed\n"); 
    1175930 
    1176931        return err; 
    1177932} 
    1178933 
    1179 static void rtl8366rb_switch_cleanup(struct rtl8366rb *rtl) 
    1180 { 
    1181         unregister_switch(&rtl->dev); 
     934static void rtl8366rb_switch_cleanup(struct rtl8366_smi *smi) 
     935{ 
     936        unregister_switch(&smi->sw_dev); 
    1182937} 
    1183938 
     
    1214969} 
    1215970 
    1216 static int rtl8366rb_setup(struct rtl8366rb *rtl) 
    1217 { 
    1218         struct rtl8366_smi *smi = &rtl->smi; 
     971static int rtl8366rb_setup(struct rtl8366_smi *smi) 
     972{ 
    1219973        int ret; 
    1220974 
     
    12621016static struct rtl8366_smi_ops rtl8366rb_smi_ops = { 
    12631017        .detect         = rtl8366rb_detect, 
     1018        .setup          = rtl8366rb_setup, 
     1019 
    12641020        .mii_read       = rtl8366rb_mii_read, 
    12651021        .mii_write      = rtl8366rb_mii_write, 
     
    12721028        .set_mc_index   = rtl8366rb_set_mc_index, 
    12731029        .get_mib_counter = rtl8366rb_get_mib_counter, 
     1030        .is_vlan_valid  = rtl8366rb_is_vlan_valid, 
    12741031}; 
    12751032 
     
    12781035        static int rtl8366_smi_version_printed; 
    12791036        struct rtl8366rb_platform_data *pdata; 
    1280         struct rtl8366rb *rtl; 
    12811037        struct rtl8366_smi *smi; 
    12821038        int err; 
     
    12931049        } 
    12941050 
    1295         rtl = kzalloc(sizeof(*rtl), GFP_KERNEL); 
    1296         if (!rtl) { 
    1297                 dev_err(&pdev->dev, "no memory for private data\n"); 
     1051        smi = rtl8366_smi_alloc(&pdev->dev); 
     1052        if (!smi) { 
    12981053                err = -ENOMEM; 
    12991054                goto err_out; 
    13001055        } 
    13011056 
    1302         rtl->parent = &pdev->dev; 
    1303  
    1304         smi = &rtl->smi; 
    1305         smi->parent = &pdev->dev; 
    13061057        smi->gpio_sda = pdata->gpio_sda; 
    13071058        smi->gpio_sck = pdata->gpio_sck; 
     
    13151066        err = rtl8366_smi_init(smi); 
    13161067        if (err) 
    1317                 goto err_free_rtl; 
    1318  
    1319         platform_set_drvdata(pdev, rtl); 
    1320  
    1321         err = rtl8366rb_setup(rtl); 
    1322         if (err) 
    1323                 goto err_clear_drvdata; 
    1324  
    1325         err = rtl8366rb_switch_init(rtl); 
     1068                goto err_free_smi; 
     1069 
     1070        platform_set_drvdata(pdev, smi); 
     1071 
     1072        err = rtl8366rb_switch_init(smi); 
    13261073        if (err) 
    13271074                goto err_clear_drvdata; 
     
    13321079        platform_set_drvdata(pdev, NULL); 
    13331080        rtl8366_smi_cleanup(smi); 
    1334  err_free_rtl: 
    1335         kfree(rtl); 
     1081 err_free_smi: 
     1082        kfree(smi); 
    13361083 err_out: 
    13371084        return err; 
     
    13661113static int __devexit rtl8366rb_remove(struct platform_device *pdev) 
    13671114{ 
    1368         struct rtl8366rb *rtl = platform_get_drvdata(pdev); 
    1369  
    1370         if (rtl) { 
    1371                 rtl8366rb_switch_cleanup(rtl); 
     1115        struct rtl8366_smi *smi = platform_get_drvdata(pdev); 
     1116 
     1117        if (smi) { 
     1118                rtl8366rb_switch_cleanup(smi); 
    13721119                platform_set_drvdata(pdev, NULL); 
    1373                 rtl8366_smi_cleanup(&rtl->smi); 
    1374                 kfree(rtl); 
     1120                rtl8366_smi_cleanup(smi); 
     1121                kfree(smi); 
    13751122        } 
    13761123 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366s.c

    r22657 r22677  
    1616#include <linux/delay.h> 
    1717#include <linux/skbuff.h> 
    18 #include <linux/switch.h> 
    1918#include <linux/rtl8366s.h> 
    2019 
     
    111110#define RTL8366S_TABLE_VLAN_WRITE_CTRL          0x0F01 
    112111 
    113 #define RTL8366S_VLAN_MEMCONF_BASE              0x0016 
     112#define RTL8366S_VLAN_MC_BASE(_x)               (0x0016 + (_x) * 2) 
    114113 
    115114#define RTL8366S_VLAN_MEMBERINGRESS_REG         0x0379 
     
    162161                                         RTL8366S_PORT_CPU) 
    163162 
    164 struct rtl8366s { 
    165         struct device           *parent; 
    166         struct rtl8366_smi      smi; 
    167         struct switch_dev       dev; 
    168 }; 
    169  
    170 struct rtl8366s_vlan_mc { 
    171         u16     reserved2:1; 
    172         u16     priority:3; 
    173         u16     vid:12; 
    174  
    175         u16     reserved1:1; 
    176         u16     fid:3; 
    177         u16     untag:6; 
    178         u16     member:6; 
    179 }; 
    180  
    181 struct rtl8366s_vlan_4k { 
    182         u16     reserved1:4; 
    183         u16     vid:12; 
    184  
    185         u16     reserved2:1; 
    186         u16     fid:3; 
    187         u16     untag:6; 
    188         u16     member:6; 
    189 }; 
     163#define RTL8366S_VLAN_VID_MASK          0xfff 
     164#define RTL8366S_VLAN_PRIORITY_SHIFT    12 
     165#define RTL8366S_VLAN_PRIORITY_MASK     0x7 
     166#define RTL8366S_VLAN_MEMBER_MASK       0x3f 
     167#define RTL8366S_VLAN_UNTAG_SHIFT       6 
     168#define RTL8366S_VLAN_UNTAG_MASK        0x3f 
     169#define RTL8366S_VLAN_FID_SHIFT         12 
     170#define RTL8366S_VLAN_FID_MASK          0x7 
    190171 
    191172static struct rtl8366_mib_counter rtl8366s_mib_counters[] = { 
     
    244225        } while (0) 
    245226 
    246 static inline struct rtl8366s *smi_to_rtl8366s(struct rtl8366_smi *smi) 
    247 { 
    248         return container_of(smi, struct rtl8366s, smi); 
    249 } 
    250  
    251 static inline struct rtl8366s *sw_to_rtl8366s(struct switch_dev *sw) 
    252 { 
    253         return container_of(sw, struct rtl8366s, dev); 
    254 } 
    255  
    256 static inline struct rtl8366_smi *sw_to_rtl8366_smi(struct switch_dev *sw) 
    257 { 
    258         struct rtl8366s *rtl = sw_to_rtl8366s(sw); 
    259         return &rtl->smi; 
    260 } 
    261  
    262227static int rtl8366s_reset_chip(struct rtl8366_smi *smi) 
    263228{ 
     
    443408                                struct rtl8366_vlan_4k *vlan4k) 
    444409{ 
    445         struct rtl8366s_vlan_4k vlan4k_priv; 
     410        u32 data[2]; 
    446411        int err; 
    447         u32 data; 
    448         u16 *tableaddr; 
     412        int i; 
    449413 
    450414        memset(vlan4k, '\0', sizeof(struct rtl8366_vlan_4k)); 
    451         vlan4k_priv.vid = vid; 
    452415 
    453416        if (vid >= RTL8366S_NUM_VIDS) 
    454417                return -EINVAL; 
    455418 
    456         tableaddr = (u16 *)&vlan4k_priv; 
    457  
    458419        /* write VID */ 
    459         data = *tableaddr; 
    460         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data); 
     420        err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, 
     421                                    vid & RTL8366S_VLAN_VID_MASK); 
    461422        if (err) 
    462423                return err; 
     
    468429                return err; 
    469430 
    470         err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE, &data); 
    471         if (err) 
    472                 return err; 
    473  
    474         *tableaddr = data; 
    475         tableaddr++; 
    476  
    477         err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 1, 
    478                                    &data); 
    479         if (err) 
    480                 return err; 
    481  
    482         *tableaddr = data; 
     431        for (i = 0; i < 2; i++) { 
     432                err = rtl8366_smi_read_reg(smi, 
     433                                           RTL8366S_VLAN_TABLE_READ_BASE + i, 
     434                                           &data[i]); 
     435                if (err) 
     436                        return err; 
     437        } 
    483438 
    484439        vlan4k->vid = vid; 
    485         vlan4k->untag = vlan4k_priv.untag; 
    486         vlan4k->member = vlan4k_priv.member; 
    487         vlan4k->fid = vlan4k_priv.fid; 
     440        vlan4k->untag = (data[1] >> RTL8366S_VLAN_UNTAG_SHIFT) & 
     441                        RTL8366S_VLAN_UNTAG_MASK; 
     442        vlan4k->member = data[1] & RTL8366S_VLAN_MEMBER_MASK; 
     443        vlan4k->fid = (data[1] >> RTL8366S_VLAN_FID_SHIFT) & 
     444                        RTL8366S_VLAN_FID_MASK; 
    488445 
    489446        return 0; 
     
    493450                                const struct rtl8366_vlan_4k *vlan4k) 
    494451{ 
    495         struct rtl8366s_vlan_4k vlan4k_priv; 
     452        u32 data[2]; 
    496453        int err; 
    497         u32 data; 
    498         u16 *tableaddr; 
     454        int i; 
    499455 
    500456        if (vlan4k->vid >= RTL8366S_NUM_VIDS || 
     
    504460                return -EINVAL; 
    505461 
    506         vlan4k_priv.vid = vlan4k->vid; 
    507         vlan4k_priv.untag = vlan4k->untag; 
    508         vlan4k_priv.member = vlan4k->member; 
    509         vlan4k_priv.fid = vlan4k->fid; 
    510  
    511         tableaddr = (u16 *)&vlan4k_priv; 
    512  
    513         data = *tableaddr; 
    514  
    515         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data); 
    516         if (err) 
    517                 return err; 
    518  
    519         tableaddr++; 
    520  
    521         data = *tableaddr; 
    522  
    523         err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 1, 
    524                                     data); 
    525         if (err) 
    526                 return err; 
     462        data[0] = vlan4k->vid & RTL8366S_VLAN_VID_MASK; 
     463        data[1] = (vlan4k->member & RTL8366S_VLAN_MEMBER_MASK) | 
     464                  ((vlan4k->untag & RTL8366S_VLAN_UNTAG_MASK) << 
     465                        RTL8366S_VLAN_UNTAG_SHIFT) | 
     466                  ((vlan4k->fid & RTL8366S_VLAN_FID_MASK) << 
     467                        RTL8366S_VLAN_FID_SHIFT); 
     468 
     469        for (i = 0; i < 2; i++) { 
     470                err = rtl8366_smi_write_reg(smi, 
     471                                            RTL8366S_VLAN_TABLE_WRITE_BASE + i, 
     472                                            data[i]); 
     473                if (err) 
     474                        return err; 
     475        } 
    527476 
    528477        /* write table access control word */ 
     
    536485                                struct rtl8366_vlan_mc *vlanmc) 
    537486{ 
    538         struct rtl8366s_vlan_mc vlanmc_priv; 
     487        u32 data[2]; 
    539488        int err; 
    540         u32 addr; 
    541         u32 data; 
    542         u16 *tableaddr; 
     489        int i; 
    543490 
    544491        memset(vlanmc, '\0', sizeof(struct rtl8366_vlan_mc)); 
     
    547494                return -EINVAL; 
    548495 
    549         tableaddr = (u16 *)&vlanmc_priv; 
    550  
    551         addr = RTL8366S_VLAN_MEMCONF_BASE + (index << 1); 
    552         err = rtl8366_smi_read_reg(smi, addr, &data); 
    553         if (err) 
    554                 return err; 
    555  
    556         *tableaddr = data; 
    557         tableaddr++; 
    558  
    559         addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index << 1); 
    560         err = rtl8366_smi_read_reg(smi, addr, &data); 
    561         if (err) 
    562                 return err; 
    563  
    564         *tableaddr = data; 
    565  
    566         vlanmc->vid = vlanmc_priv.vid; 
    567         vlanmc->priority = vlanmc_priv.priority; 
    568         vlanmc->untag = vlanmc_priv.untag; 
    569         vlanmc->member = vlanmc_priv.member; 
    570         vlanmc->fid = vlanmc_priv.fid; 
     496        for (i = 0; i < 2; i++) { 
     497                err = rtl8366_smi_read_reg(smi, 
     498                                           RTL8366S_VLAN_MC_BASE(index) + i, 
     499                                           &data[i]); 
     500                if (err) 
     501                        return err; 
     502        } 
     503 
     504        vlanmc->vid = data[0] & RTL8366S_VLAN_VID_MASK; 
     505        vlanmc->priority = (data[0] >> RTL8366S_VLAN_PRIORITY_SHIFT) & 
     506                           RTL8366S_VLAN_PRIORITY_MASK; 
     507        vlanmc->untag = (data[1] >> RTL8366S_VLAN_UNTAG_SHIFT) & 
     508                        RTL8366S_VLAN_UNTAG_MASK; 
     509        vlanmc->member = data[1] & RTL8366S_VLAN_MEMBER_MASK; 
     510        vlanmc->fid = (data[1] >> RTL8366S_VLAN_FID_SHIFT) & 
     511                      RTL8366S_VLAN_FID_MASK; 
    571512 
    572513        return 0; 
     
    576517                                const struct rtl8366_vlan_mc *vlanmc) 
    577518{ 
    578         struct rtl8366s_vlan_mc vlanmc_priv; 
     519        u32 data[2]; 
    579520        int err; 
    580         u32 addr; 
    581         u32 data; 
    582         u16 *tableaddr; 
     521        int i; 
    583522 
    584523        if (index >= RTL8366S_NUM_VLANS || 
     
    590529                return -EINVAL; 
    591530 
    592         vlanmc_priv.vid = vlanmc->vid; 
    593         vlanmc_priv.priority = vlanmc->priority; 
    594         vlanmc_priv.untag = vlanmc->untag; 
    595         vlanmc_priv.member = vlanmc->member; 
    596         vlanmc_priv.fid = vlanmc->fid; 
    597  
    598         addr = RTL8366S_VLAN_MEMCONF_BASE + (index << 1); 
    599  
    600         tableaddr = (u16 *)&vlanmc_priv; 
    601         data = *tableaddr; 
    602  
    603         err = rtl8366_smi_write_reg(smi, addr, data); 
    604         if (err) 
    605                 return err; 
    606  
    607         addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index << 1); 
    608  
    609         tableaddr++; 
    610         data = *tableaddr; 
    611  
    612         err = rtl8366_smi_write_reg(smi, addr, data); 
    613         if (err) 
    614                 return err; 
     531        data[0] = (vlanmc->vid & RTL8366S_VLAN_VID_MASK) | 
     532                  ((vlanmc->priority & RTL8366S_VLAN_PRIORITY_MASK) << 
     533                        RTL8366S_VLAN_PRIORITY_SHIFT); 
     534        data[1] = (vlanmc->member & RTL8366S_VLAN_MEMBER_MASK) | 
     535                  ((vlanmc->untag & RTL8366S_VLAN_UNTAG_MASK) << 
     536                        RTL8366S_VLAN_UNTAG_SHIFT) | 
     537                  ((vlanmc->fid & RTL8366S_VLAN_FID_MASK) << 
     538                        RTL8366S_VLAN_FID_SHIFT); 
     539 
     540        for (i = 0; i < 2; i++) { 
     541                err = rtl8366_smi_write_reg(smi, 
     542                                            RTL8366S_VLAN_MC_BASE(index) + i, 
     543                                            data[i]); 
     544                if (err) 
     545                        return err; 
     546        } 
    615547 
    616548        return 0; 
     
    660592} 
    661593 
     594static int rtl8366s_is_vlan_valid(struct rtl8366_smi *smi, unsigned vlan) 
     595{ 
     596        if (vlan == 0 || vlan >= RTL8366S_NUM_VLANS) 
     597                return 0; 
     598 
     599        return 1; 
     600} 
     601 
    662602static int rtl8366s_sw_reset_mibs(struct switch_dev *dev, 
    663603                                  const struct switch_attr *attr, 
     
    665605{ 
    666606        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    667         int err = 0; 
    668  
    669         if (val->value.i == 1) 
    670                 err = rtl8366_smi_rmwr(smi, RTL8366S_MIB_CTRL_REG, 0, (1 << 2)); 
    671  
    672         return err; 
     607 
     608        return rtl8366_smi_rmwr(smi, RTL8366S_MIB_CTRL_REG, 0, (1 << 2)); 
    673609} 
    674610 
     
    830766} 
    831767 
    832 static int rtl8366s_sw_get_vlan_info(struct switch_dev *dev, 
    833                                      const struct switch_attr *attr, 
    834                                      struct switch_val *val) 
    835 { 
    836         int i; 
    837         u32 len = 0; 
    838         struct rtl8366_vlan_4k vlan4k; 
    839         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    840         char *buf = smi->buf; 
    841         int err; 
    842  
    843         if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    844                 return -EINVAL; 
    845  
    846         memset(buf, '\0', sizeof(smi->buf)); 
    847  
    848         err = rtl8366s_get_vlan_4k(smi, val->port_vlan, &vlan4k); 
    849         if (err) 
    850                 return err; 
    851  
    852         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    853                         "VLAN %d: Ports: '", vlan4k.vid); 
    854  
    855         for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
    856                 if (!(vlan4k.member & (1 << i))) 
    857                         continue; 
    858  
    859                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i, 
    860                                 (vlan4k.untag & (1 << i)) ? "" : "t"); 
    861         } 
    862  
    863         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    864                         "', members=%04x, untag=%04x, fid=%u", 
    865                         vlan4k.member, vlan4k.untag, vlan4k.fid); 
    866  
    867         val->value.s = buf; 
    868         val->len = len; 
    869  
    870         return 0; 
    871 } 
    872  
    873768static int rtl8366s_sw_set_port_led(struct switch_dev *dev, 
    874769                                    const struct switch_attr *attr, 
     
    925820        return rtl8366_smi_rmwr(smi, RTL8366S_MIB_CTRL_REG, 
    926821                                0, (1 << (val->port_vlan + 3))); 
    927 } 
    928  
    929 static int rtl8366s_sw_get_port_mib(struct switch_dev *dev, 
    930                                     const struct switch_attr *attr, 
    931                                     struct switch_val *val) 
    932 { 
    933         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    934         int i, len = 0; 
    935         unsigned long long counter = 0; 
    936         char *buf = smi->buf; 
    937  
    938         if (val->port_vlan >= RTL8366S_NUM_PORTS) 
    939                 return -EINVAL; 
    940  
    941         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    942                         "Port %d MIB counters\n", 
    943                         val->port_vlan); 
    944  
    945         for (i = 0; i < ARRAY_SIZE(rtl8366s_mib_counters); ++i) { 
    946                 len += snprintf(buf + len, sizeof(smi->buf) - len, 
    947                                 "%-36s: ", rtl8366s_mib_counters[i].name); 
    948                 if (!rtl8366_get_mib_counter(smi, i, val->port_vlan, &counter)) 
    949                         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    950                                         "%llu\n", counter); 
    951                 else 
    952                         len += snprintf(buf + len, sizeof(smi->buf) - len, 
    953                                         "%s\n", "error"); 
    954         } 
    955  
    956         val->value.s = buf; 
    957         val->len = len; 
    958         return 0; 
    959 } 
    960  
    961 static int rtl8366s_sw_get_vlan_ports(struct switch_dev *dev, 
    962                                       struct switch_val *val) 
    963 { 
    964         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    965         struct switch_port *port; 
    966         struct rtl8366_vlan_4k vlan4k; 
    967         int i; 
    968  
    969         if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    970                 return -EINVAL; 
    971  
    972         rtl8366s_get_vlan_4k(smi, val->port_vlan, &vlan4k); 
    973  
    974         port = &val->value.ports[0]; 
    975         val->len = 0; 
    976         for (i = 0; i < RTL8366S_NUM_PORTS; i++) { 
    977                 if (!(vlan4k.member & BIT(i))) 
    978                         continue; 
    979  
    980                 port->id = i; 
    981                 port->flags = (vlan4k.untag & BIT(i)) ? 
    982                                         0 : BIT(SWITCH_PORT_FLAG_TAGGED); 
    983                 val->len++; 
    984                 port++; 
    985         } 
    986         return 0; 
    987 } 
    988  
    989 static int rtl8366s_sw_set_vlan_ports(struct switch_dev *dev, 
    990                                       struct switch_val *val) 
    991 { 
    992         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    993         struct switch_port *port; 
    994         u32 member = 0; 
    995         u32 untag = 0; 
    996         int i; 
    997  
    998         if (val->port_vlan == 0 || val->port_vlan >= RTL8366S_NUM_VLANS) 
    999                 return -EINVAL; 
    1000  
    1001         port = &val->value.ports[0]; 
    1002         for (i = 0; i < val->len; i++, port++) { 
    1003                 member |= BIT(port->id); 
    1004  
    1005                 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED))) 
    1006                         untag |= BIT(port->id); 
    1007         } 
    1008  
    1009         return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0); 
    1010 } 
    1011  
    1012 static int rtl8366s_sw_get_port_pvid(struct switch_dev *dev, int port, int *val) 
    1013 { 
    1014         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1015         return rtl8366_get_pvid(smi, port, val); 
    1016 } 
    1017  
    1018 static int rtl8366s_sw_set_port_pvid(struct switch_dev *dev, int port, int val) 
    1019 { 
    1020         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev); 
    1021         return rtl8366_set_pvid(smi, port, val); 
    1022822} 
    1023823 
     
    1063863                .ofs = 2 
    1064864        }, { 
    1065                 .type = SWITCH_TYPE_INT, 
     865                .type = SWITCH_TYPE_NOVAL, 
    1066866                .name = "reset_mibs", 
    1067867                .description = "Reset all MIB counters", 
    1068868                .set = rtl8366s_sw_reset_mibs, 
    1069                 .get = NULL, 
    1070                 .max = 1 
    1071869        }, { 
    1072870                .type = SWITCH_TYPE_INT, 
     
    1089887                .get = rtl8366s_sw_get_port_link, 
    1090888        }, { 
    1091                 .type = SWITCH_TYPE_INT, 
     889                .type = SWITCH_TYPE_NOVAL, 
    1092890                .name = "reset_mib", 
    1093891                .description = "Reset single port MIB counters", 
    1094                 .max = 1, 
    1095892                .set = rtl8366s_sw_reset_port_mibs, 
    1096                 .get = NULL, 
    1097893        }, { 
    1098894                .type = SWITCH_TYPE_STRING, 
     
    1101897                .max = 33, 
    1102898                .set = NULL, 
    1103                 .get = rtl8366s_sw_get_port_mib, 
     899                .get = rtl8366_sw_get_port_mib, 
    1104900        }, { 
    1105901                .type = SWITCH_TYPE_INT, 
     
    1119915                .max = 1, 
    1120916                .set = NULL, 
    1121                 .get = rtl8366s_sw_get_vlan_info, 
     917                .get = rtl8366_sw_get_vlan_info, 
    1122918        }, 
    1123919}; 
    1124920 
    1125 /* template */ 
    1126 static struct switch_dev rtl8366_switch_dev = { 
    1127         .name = "RTL8366S", 
    1128         .cpu_port = RTL8366S_PORT_NUM_CPU, 
    1129         .ports = RTL8366S_NUM_PORTS, 
    1130         .vlans = RTL8366S_NUM_VLANS, 
     921static const struct switch_dev_ops rtl8366_ops = { 
    1131922        .attr_global = { 
    1132923                .attr = rtl8366s_globals, 
     
    1142933        }, 
    1143934 
    1144         .get_vlan_ports = rtl8366s_sw_get_vlan_ports, 
    1145         .set_vlan_ports = rtl8366s_sw_set_vlan_ports, 
    1146         .get_port_pvid = rtl8366s_sw_get_port_pvid, 
    1147         .set_port_pvid = rtl8366s_sw_set_port_pvid, 
     935        .get_vlan_ports = rtl8366_sw_get_vlan_ports, 
     936        .set_vlan_ports = rtl8366_sw_set_vlan_ports, 
     937        .get_port_pvid = rtl8366_sw_get_port_pvid, 
     938        .set_port_pvid = rtl8366_sw_set_port_pvid, 
    1148939        .reset_switch = rtl8366s_sw_reset_switch, 
    1149940}; 
    1150941 
    1151 static int rtl8366s_switch_init(struct rtl8366s *rtl) 
    1152 { 
    1153         struct switch_dev *dev = &rtl->dev; 
     942static int rtl8366s_switch_init(struct rtl8366_smi *smi) 
     943{ 
     944        struct switch_dev *dev = &smi->sw_dev; 
    1154945        int err; 
    1155946 
    1156         memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev)); 
    1157         dev->priv = rtl; 
    1158         dev->devname = dev_name(rtl->parent); 
     947        dev->name = "RTL8366S"; 
     948        dev->cpu_port = RTL8366S_PORT_NUM_CPU; 
     949        dev->ports = RTL8366S_NUM_PORTS; 
     950        dev->vlans = RTL8366S_NUM_VLANS; 
     951        dev->ops = &rtl8366_ops; 
     952        dev->devname = dev_name(smi->parent); 
    1159953 
    1160954        err = register_switch(dev, NULL); 
    1161955        if (err) 
    1162                 dev_err(rtl->parent, "switch registration failed\n"); 
     956                dev_err(smi->parent, "switch registration failed\n"); 
    1163957 
    1164958        return err; 
    1165959} 
    1166960 
    1167 static void rtl8366s_switch_cleanup(struct rtl8366s *rtl) 
    1168 { 
    1169         unregister_switch(&rtl->dev); 
     961static void rtl8366s_switch_cleanup(struct rtl8366_smi *smi) 
     962{ 
     963        unregister_switch(&smi->sw_dev); 
    1170964} 
    1171965 
     
    1202996} 
    1203997 
    1204 static int rtl8366s_setup(struct rtl8366s *rtl) 
    1205 { 
    1206         struct rtl8366_smi *smi = &rtl->smi; 
     998static int rtl8366s_setup(struct rtl8366_smi *smi) 
     999{ 
    12071000        int ret; 
    12081001 
     
    12501043static struct rtl8366_smi_ops rtl8366s_smi_ops = { 
    12511044        .detect         = rtl8366s_detect, 
     1045        .setup          = rtl8366s_setup, 
     1046 
    12521047        .mii_read       = rtl8366s_mii_read, 
    12531048        .mii_write      = rtl8366s_mii_write, 
     
    12601055        .set_mc_index   = rtl8366s_set_mc_index, 
    12611056        .get_mib_counter = rtl8366_get_mib_counter, 
     1057        .is_vlan_valid  = rtl8366s_is_vlan_valid, 
    12621058}; 
    12631059 
     
    12661062        static int rtl8366_smi_version_printed; 
    12671063        struct rtl8366s_platform_data *pdata; 
    1268         struct rtl8366s *rtl; 
    12691064        struct rtl8366_smi *smi; 
    12701065        int err; 
     
    12811076        } 
    12821077 
    1283         rtl = kzalloc(sizeof(*rtl), GFP_KERNEL); 
    1284         if (!rtl) { 
    1285                 dev_err(&pdev->dev, "no memory for private data\n"); 
     1078        smi = rtl8366_smi_alloc(&pdev->dev); 
     1079        if (!smi) { 
    12861080                err = -ENOMEM; 
    12871081                goto err_out; 
    12881082        } 
    12891083 
    1290         rtl->parent = &pdev->dev; 
    1291  
    1292         smi = &rtl->smi; 
    1293         smi->parent = &pdev->dev; 
    12941084        smi->gpio_sda = pdata->gpio_sda; 
    12951085        smi->gpio_sck = pdata->gpio_sck; 
     
    13031093        err = rtl8366_smi_init(smi); 
    13041094        if (err) 
    1305                 goto err_free_rtl; 
    1306  
    1307         platform_set_drvdata(pdev, rtl); 
    1308  
    1309         err = rtl8366s_setup(rtl); 
    1310         if (err) 
    1311                 goto err_clear_drvdata; 
    1312  
    1313         err = rtl8366s_switch_init(rtl); 
     1095                goto err_free_smi; 
     1096 
     1097        platform_set_drvdata(pdev, smi); 
     1098 
     1099        err = rtl8366s_switch_init(smi); 
    13141100        if (err) 
    13151101                goto err_clear_drvdata; 
     
    13201106        platform_set_drvdata(pdev, NULL); 
    13211107        rtl8366_smi_cleanup(smi); 
    1322  err_free_rtl: 
    1323         kfree(rtl); 
     1108 err_free_smi: 
     1109        kfree(smi); 
    13241110 err_out: 
    13251111        return err; 
     
    13541140static int __devexit rtl8366s_remove(struct platform_device *pdev) 
    13551141{ 
    1356         struct rtl8366s *rtl = platform_get_drvdata(pdev); 
    1357  
    1358         if (rtl) { 
    1359                 rtl8366s_switch_cleanup(rtl); 
     1142        struct rtl8366_smi *smi = platform_get_drvdata(pdev); 
     1143 
     1144        if (smi) { 
     1145                rtl8366s_switch_cleanup(smi); 
    13601146                platform_set_drvdata(pdev, NULL); 
    1361                 rtl8366_smi_cleanup(&rtl->smi); 
    1362                 kfree(rtl); 
     1147                rtl8366_smi_cleanup(smi); 
     1148                kfree(smi); 
    13631149        } 
    13641150 
  • branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/swconfig.c

    r21847 r22677  
    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: 
  • branches/backfire/target/linux/generic-2.6/files/include/linux/switch.h

    r20948 r22677  
    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 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.30/670-phy_ip175c.patch

    r16287 r22677  
    55        tristate "Driver for Marvell 88E6060 switches" 
    66  
    7 +config IP175C_PHY 
     7+config IP17XX_PHY 
    88+       tristate "Driver for IC+ IP175C/IP178C switches" 
    99+       select SWCONFIG 
     
    1818 obj-$(CONFIG_ADM6996_PHY)      += adm6996.o 
    1919 obj-$(CONFIG_MVSWITCH_PHY)     += mvswitch.o 
    20 +obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     20+obj-$(CONFIG_IP17XX_PHY)       += ip17xx.o 
    2121 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    2222 obj-$(CONFIG_LSI_ET1011C_PHY)  += et1011c.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.30/680-phy_ar8216.patch

    r16307 r22677  
    11--- a/drivers/net/phy/Kconfig 
    22+++ b/drivers/net/phy/Kconfig 
    3 @@ -100,6 +100,10 @@ config IP175C_PHY 
     3@@ -100,6 +100,10 @@ config IP17XX_PHY 
    44        tristate "Driver for IC+ IP175C/IP178C switches" 
    55        select SWCONFIG 
     
    1616@@ -17,6 +17,7 @@ obj-$(CONFIG_ADM6996_PHY)     += adm6996.o 
    1717 obj-$(CONFIG_MVSWITCH_PHY)     += mvswitch.o 
    18  obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     18 obj-$(CONFIG_IP17XX_PHY)       += ip17xx.o 
    1919 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    2020+obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.30/690-phy_rtl8306.patch

    r17248 r22677  
    1515+++ b/drivers/net/phy/Makefile 
    1616@@ -18,6 +18,7 @@ obj-$(CONFIG_MVSWITCH_PHY)    += mvswitch.o 
    17  obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     17 obj-$(CONFIG_IP17XX_PHY)       += ip17xx.o 
    1818 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    1919 obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.30/691-phy_rtl8366.patch

    r19837 r22677  
    3333--- a/drivers/net/phy/Makefile 
    3434+++ b/drivers/net/phy/Makefile 
    35 @@ -19,6 +19,9 @@ obj-$(CONFIG_IP175C_PHY)      += ip175c.o 
     35@@ -19,6 +19,9 @@ obj-$(CONFIG_IP17XX_PHY)      += ip17xx.o 
    3636 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    3737 obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.32/670-phy_ip175c.patch

    r18283 r22677  
    55        tristate "Driver for Marvell 88E6060 switches" 
    66  
    7 +config IP175C_PHY 
     7+config IP17XX_PHY 
    88+       tristate "Driver for IC+ IP175C/IP178C switches" 
    99+       select SWCONFIG 
     
    1818 obj-$(CONFIG_ADM6996_PHY)      += adm6996.o 
    1919 obj-$(CONFIG_MVSWITCH_PHY)     += mvswitch.o 
    20 +obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     20+obj-$(CONFIG_IP17XX_PHY)       += ip17xx.o 
    2121 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    2222 obj-$(CONFIG_LSI_ET1011C_PHY)  += et1011c.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.32/680-phy_ar8216.patch

    r18283 r22677  
    11--- a/drivers/net/phy/Kconfig 
    22+++ b/drivers/net/phy/Kconfig 
    3 @@ -106,6 +106,10 @@ config IP175C_PHY 
     3@@ -106,6 +106,10 @@ config IP17XX_PHY 
    44        tristate "Driver for IC+ IP175C/IP178C switches" 
    55        select SWCONFIG 
     
    1616@@ -18,6 +18,7 @@ obj-$(CONFIG_ADM6996_PHY)     += adm6996.o 
    1717 obj-$(CONFIG_MVSWITCH_PHY)     += mvswitch.o 
    18  obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     18 obj-$(CONFIG_IP17XX_PHY)       += ip17xx.o 
    1919 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    2020+obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.32/690-phy_rtl8306.patch

    r18283 r22677  
    1515+++ b/drivers/net/phy/Makefile 
    1616@@ -19,6 +19,7 @@ obj-$(CONFIG_MVSWITCH_PHY)    += mvswitch.o 
    17  obj-$(CONFIG_IP175C_PHY)       += ip175c.o 
     17 obj-$(CONFIG_IP17XX)   += ip17xx.o 
    1818 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    1919 obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
  • branches/backfire/target/linux/generic-2.6/patches-2.6.32/691-phy_rtl8366.patch

    r19837 r22677  
    3333--- a/drivers/net/phy/Makefile 
    3434+++ b/drivers/net/phy/Makefile 
    35 @@ -20,6 +20,9 @@ obj-$(CONFIG_IP175C_PHY)      += ip175c.o 
     35@@ -20,6 +20,9 @@ obj-$(CONFIG_IP17XX_PHY)      += ip17xx.o 
    3636 obj-$(CONFIG_REALTEK_PHY)      += realtek.o 
    3737 obj-$(CONFIG_AR8216_PHY)       += ar8216.o 
Note: See TracChangeset for help on using the changeset viewer.