Changeset 40842


Ignore:
Timestamp:
2014-05-24T19:04:12+02:00 (4 years ago)
Author:
jow
Message:

Revert "ar71xx: Fix tagged+untagged operation on AR8327N (#12181)"

Revert the tagged + untagged rework for now due to regressions in
vlan setup on certain AR83xx switches.

Signed-off-by: Jo-Philipp Wich <jow@…>

File:
1 edited

Legend:

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

    r40777 r40842  
    7474        void (*init_globals)(struct ar8xxx_priv *priv); 
    7575        void (*init_port)(struct ar8xxx_priv *priv, int port); 
    76         void (*setup_port)(struct ar8xxx_priv *priv, int port, u32 members); 
     76        void (*setup_port)(struct ar8xxx_priv *priv, int port, u32 egress, 
     77                           u32 ingress, u32 members, u32 pvid); 
    7778        u32 (*read_port_status)(struct ar8xxx_priv *priv, int port); 
    7879        int (*atu_flush)(struct ar8xxx_priv *priv); 
    7980        void (*vtu_flush)(struct ar8xxx_priv *priv); 
    80         void (*vtu_load_vlan)(struct ar8xxx_priv *priv, u32 vlan); 
     81        void (*vtu_load_vlan)(struct ar8xxx_priv *priv, u32 vid, u32 port_mask); 
    8182 
    8283        const struct ar8xxx_mib_desc *mib_decs; 
     
    112113}; 
    113114 
    114 struct ar8216_data { 
    115         u8 vlan_tagged; 
    116 }; 
    117  
    118115struct ar8327_data { 
    119         u8 vlan_tagged[AR8X16_MAX_VLANS]; 
    120116        u32 port0_status; 
    121117        u32 port6_status; 
     
    143139        const struct ar8xxx_chip *chip; 
    144140        union { 
    145                 struct ar8216_data ar8216; 
    146141                struct ar8327_data ar8327; 
    147142        } chip_data; 
     
    165160        u16 vlan_id[AR8X16_MAX_VLANS]; 
    166161        u8 vlan_table[AR8X16_MAX_VLANS]; 
     162        u8 vlan_tagged; 
    167163        u16 pvid[AR8X16_MAX_PORTS]; 
    168164 
     
    646642 
    647643        /* no need to fix up packets coming from a tagged source */ 
    648         if (priv->chip_data.ar8216.vlan_tagged & BIT(port)) 
     644        if (priv->vlan_tagged & (1 << port)) 
    649645                return; 
    650646 
     
    700696 
    701697static void 
    702 ar8216_vtu_load_vlan(struct ar8xxx_priv *priv, u32 vlan) 
     698ar8216_vtu_load_vlan(struct ar8xxx_priv *priv, u32 vid, u32 port_mask) 
    703699{ 
    704700        u32 op; 
    705701 
    706         u32 vid = priv->vlan_id[vlan]; 
    707         u32 port_mask = priv->vlan_table[vlan]; 
    708  
    709702        op = AR8216_VTU_OP_LOAD | (vid << AR8216_VTU_VID_S); 
    710  
    711703        ar8216_vtu_op(priv, op, port_mask); 
    712704} 
     
    731723 
    732724static void 
    733 ar8216_setup_port(struct ar8xxx_priv *priv, int port, u32 members) 
     725ar8216_setup_port(struct ar8xxx_priv *priv, int port, u32 egress, u32 ingress, 
     726                  u32 members, u32 pvid) 
    734727{ 
    735728        u32 header; 
    736         u32 egress, ingress; 
    737         u32 pvid; 
    738  
    739         if (priv->vlan) { 
    740                 pvid = priv->vlan_id[priv->pvid[port]]; 
    741                 if (priv->chip_data.ar8216.vlan_tagged & BIT(port)) 
    742                         egress = AR8216_OUT_ADD_VLAN; 
    743                 else 
    744                         egress = AR8216_OUT_STRIP_VLAN; 
    745                 ingress = AR8216_IN_SECURE; 
    746         } else { 
    747                 pvid = port; 
    748                 egress = AR8216_OUT_KEEP; 
    749                 ingress = AR8216_IN_PORT_ONLY; 
    750         } 
    751  
    752  
    753729 
    754730        if (chip_is_ar8216(priv) && priv->vlan && port == AR8216_PORT_CPU) 
     
    832808 
    833809static void 
    834 ar8236_setup_port(struct ar8xxx_priv *priv, int port, u32 members) 
    835 { 
    836         u32 egress, ingress; 
    837         u32 pvid; 
    838  
    839         if (priv->vlan) { 
    840                 pvid = priv->vlan_id[priv->pvid[port]]; 
    841                 if (priv->chip_data.ar8216.vlan_tagged & BIT(port)) 
    842                         egress = AR8216_OUT_ADD_VLAN; 
    843                 else 
    844                         egress = AR8216_OUT_STRIP_VLAN; 
    845                 ingress = AR8216_IN_SECURE; 
    846         } else { 
    847                 pvid = port; 
    848                 egress = AR8216_OUT_KEEP; 
    849                 ingress = AR8216_IN_PORT_ONLY; 
    850         } 
    851  
     810ar8236_setup_port(struct ar8xxx_priv *priv, int port, u32 egress, u32 ingress, 
     811                  u32 members, u32 pvid) 
     812{ 
    852813        ar8xxx_rmw(priv, AR8216_REG_PORT_CTRL(port), 
    853814                   AR8216_PORT_CTRL_LEARN | AR8216_PORT_CTRL_VLAN_MODE | 
     
    17361697 
    17371698static void 
    1738 ar8327_vtu_load_vlan(struct ar8xxx_priv *priv, u32 vlan) 
    1739 { 
    1740         u32 op, val; 
     1699ar8327_vtu_load_vlan(struct ar8xxx_priv *priv, u32 vid, u32 port_mask) 
     1700{ 
     1701        u32 op; 
     1702        u32 val; 
    17411703        int i; 
    1742  
    1743         u32 vid = priv->vlan_id[vlan]; 
    1744         u32 port_mask = priv->vlan_table[vlan]; 
    1745         u32 tagged = priv->chip_data.ar8327.vlan_tagged[vlan]; 
    1746  
    17471704 
    17481705        op = AR8327_VTU_FUNC1_OP_LOAD | (vid << AR8327_VTU_FUNC1_VID_S); 
     
    17551712                else if (priv->vlan == 0) 
    17561713                        mode = AR8327_VTU_FUNC0_EG_MODE_KEEP; 
    1757                 else if (tagged & BIT(i)) 
     1714                else if (priv->vlan_tagged & BIT(i)) 
    17581715                        mode = AR8327_VTU_FUNC0_EG_MODE_TAG; 
    17591716                else 
     
    17661723 
    17671724static void 
    1768 ar8327_setup_port(struct ar8xxx_priv *priv, int port, u32 members) 
    1769 { 
    1770         u32 ingress, mode; 
    1771         u32 pvid; 
    1772  
     1725ar8327_setup_port(struct ar8xxx_priv *priv, int port, u32 egress, u32 ingress, 
     1726                  u32 members, u32 pvid) 
     1727{ 
    17731728        u32 t; 
    1774  
    1775         if (priv->vlan) { 
    1776                 pvid = priv->vlan_id[priv->pvid[port]]; 
    1777                 mode = AR8327_PORT_VLAN1_OUT_MODE_UNMOD; 
    1778                 ingress = AR8216_IN_SECURE; 
    1779         } else { 
    1780                 pvid = port; 
    1781                 mode = AR8327_PORT_VLAN1_OUT_MODE_UNTOUCH; 
    1782                 ingress = AR8216_IN_PORT_ONLY; 
    1783         } 
     1729        u32 mode; 
    17841730 
    17851731        t = pvid << AR8327_PORT_VLAN0_DEF_SVID_S; 
    17861732        t |= pvid << AR8327_PORT_VLAN0_DEF_CVID_S; 
    17871733        priv->write(priv, AR8327_REG_PORT_VLAN0(port), t); 
     1734 
     1735        mode = AR8327_PORT_VLAN1_OUT_MODE_UNMOD; 
     1736        switch (egress) { 
     1737        case AR8216_OUT_KEEP: 
     1738                mode = AR8327_PORT_VLAN1_OUT_MODE_UNTOUCH; 
     1739                break; 
     1740        case AR8216_OUT_STRIP_VLAN: 
     1741                mode = AR8327_PORT_VLAN1_OUT_MODE_UNTAG; 
     1742                break; 
     1743        case AR8216_OUT_ADD_VLAN: 
     1744                mode = AR8327_PORT_VLAN1_OUT_MODE_TAG; 
     1745                break; 
     1746        } 
    17881747 
    17891748        t = AR8327_PORT_VLAN1_PORT_VLAN_PROP; 
     
    18841843 
    18851844static int 
    1886 ar8xxx_sw_get_ports(struct switch_val *val, int ports, u8 port_mask, u8 tagged) 
    1887 { 
     1845ar8xxx_sw_get_ports(struct switch_dev *dev, struct switch_val *val) 
     1846{ 
     1847        struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev); 
     1848        u8 ports = priv->vlan_table[val->port_vlan]; 
    18881849        int i; 
     1850 
    18891851        val->len = 0; 
    1890         for (i = 0; i < ports; i++) { 
     1852        for (i = 0; i < dev->ports; i++) { 
    18911853                struct switch_port *p; 
    18921854 
    1893                 if (!(port_mask & BIT(i))) 
     1855                if (!(ports & (1 << i))) 
    18941856                        continue; 
    18951857 
    18961858                p = &val->value.ports[val->len++]; 
    18971859                p->id = i; 
    1898                 if (tagged & BIT(i)) 
    1899                         p->flags = BIT(SWITCH_PORT_FLAG_TAGGED); 
     1860                if (priv->vlan_tagged & (1 << i)) 
     1861                        p->flags = (1 << SWITCH_PORT_FLAG_TAGGED); 
    19001862                else 
    19011863                        p->flags = 0; 
     
    19051867 
    19061868static int 
    1907 ar8216_sw_get_ports(struct switch_dev *dev, struct switch_val *val) 
    1908 { 
    1909         int ports = dev->ports; 
    1910         struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev); 
    1911         u8 port_mask = priv->vlan_table[val->port_vlan]; 
    1912         u8 tagged = priv->chip_data.ar8216.vlan_tagged; 
    1913  
    1914         return ar8xxx_sw_get_ports(val, ports, port_mask, tagged); 
    1915 } 
    1916  
    1917 static int 
    1918 ar8327_sw_get_ports(struct switch_dev *dev, struct switch_val *val) 
    1919 { 
    1920         int ports = dev->ports; 
    1921         struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev); 
    1922         u8 port_mask = priv->vlan_table[val->port_vlan]; 
    1923         u8 tagged = priv->chip_data.ar8327.vlan_tagged[val->port_vlan]; 
    1924  
    1925         return ar8xxx_sw_get_ports(val, ports, port_mask, tagged); 
    1926 } 
    1927  
    1928 static int 
    1929 ar8216_sw_set_ports(struct switch_dev *dev, struct switch_val *val) 
     1869ar8xxx_sw_set_ports(struct switch_dev *dev, struct switch_val *val) 
    19301870{ 
    19311871        struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev); 
    19321872        u8 *vt = &priv->vlan_table[val->port_vlan]; 
    1933         u8 *tagged = &priv->chip_data.ar8216.vlan_tagged; 
    1934  
    19351873        int i, j; 
    19361874 
     
    19391877                struct switch_port *p = &val->value.ports[i]; 
    19401878 
    1941                 if (p->flags & BIT(SWITCH_PORT_FLAG_TAGGED)) { 
    1942  
    1943                         /* if port was untagged before then 
    1944                          * remove him from other vlans */ 
    1945                         if(*tagged & BIT(p->id)){ 
    1946                                 for (j = 0; j < AR8X16_MAX_VLANS; j++) { 
    1947                                         if (j == val->port_vlan) 
    1948                                                 continue; 
    1949  
    1950                                         priv->vlan_table[j] &= ~(BIT(p->id)); 
    1951                                 } 
    1952                         } 
    1953  
    1954                         *tagged |= BIT(p->id); 
     1879                if (p->flags & (1 << SWITCH_PORT_FLAG_TAGGED)) { 
     1880                        priv->vlan_tagged |= (1 << p->id); 
    19551881                } else { 
    1956                         *tagged &= ~(BIT(p->id)); 
     1882                        priv->vlan_tagged &= ~(1 << p->id); 
    19571883                        priv->pvid[p->id] = val->port_vlan; 
    19581884 
     
    19621888                                if (j == val->port_vlan) 
    19631889                                        continue; 
    1964  
    1965                                 priv->vlan_table[j] &= ~(BIT(p->id)); 
     1890                                priv->vlan_table[j] &= ~(1 << p->id); 
    19661891                        } 
    19671892                } 
    19681893 
    1969                 *vt |= BIT(p->id); 
    1970         } 
    1971         return 0; 
    1972 } 
    1973  
    1974 static int 
    1975 ar8327_sw_set_ports(struct switch_dev *dev, struct switch_val *val) 
    1976 { 
    1977         struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev); 
    1978         u8 *vt = &priv->vlan_table[val->port_vlan]; 
    1979         u8 *vlan_tagged = priv->chip_data.ar8327.vlan_tagged; 
    1980         u8 *tagged = &vlan_tagged[val->port_vlan]; 
    1981  
    1982         int i, j; 
    1983  
    1984         *vt = 0; 
    1985         *tagged = 0; 
    1986         for (i = 0; i < val->len; i++) { 
    1987                 struct switch_port *p = &val->value.ports[i]; 
    1988  
    1989                 if (p->flags & BIT(SWITCH_PORT_FLAG_TAGGED)) { 
    1990                         *tagged |= BIT(p->id); 
    1991                 } else { 
    1992                         priv->pvid[p->id] = val->port_vlan; 
    1993                 } 
    1994  
    1995                 *vt |= BIT(p->id); 
     1894                *vt |= 1 << p->id; 
    19961895        } 
    19971896        return 0; 
     
    21122011 
    21132012                        for (i = 0; i < dev->ports; i++) { 
    2114                                 u8 mask = BIT(i); 
     2013                                u8 mask = (1 << i); 
    21152014                                if (vp & mask) 
    21162015                                        portmask[i] |= vp & ~mask; 
    21172016                        } 
    2118                         priv->chip->vtu_load_vlan(priv, j); 
     2017 
     2018                        priv->chip->vtu_load_vlan(priv, priv->vlan_id[j], 
     2019                                                 priv->vlan_table[j]); 
    21192020                } 
    21202021        } else { 
     
    21252026                                continue; 
    21262027 
    2127                         portmask[i] = BIT(AR8216_PORT_CPU); 
    2128                         portmask[AR8216_PORT_CPU] |= BIT(i); 
     2028                        portmask[i] = 1 << AR8216_PORT_CPU; 
     2029                        portmask[AR8216_PORT_CPU] |= (1 << i); 
    21292030                } 
    21302031        } 
     
    21322033        /* update the port destination mask registers and tag settings */ 
    21332034        for (i = 0; i < dev->ports; i++) { 
    2134                 priv->chip->setup_port(priv, i, portmask[i]); 
     2035                int egress, ingress; 
     2036                int pvid; 
     2037 
     2038                if (priv->vlan) { 
     2039                        pvid = priv->vlan_id[priv->pvid[i]]; 
     2040                        if (priv->vlan_tagged & (1 << i)) 
     2041                                egress = AR8216_OUT_ADD_VLAN; 
     2042                        else 
     2043                                egress = AR8216_OUT_STRIP_VLAN; 
     2044                        ingress = AR8216_IN_SECURE; 
     2045                } else { 
     2046                        pvid = i; 
     2047                        egress = AR8216_OUT_KEEP; 
     2048                        ingress = AR8216_IN_PORT_ONLY; 
     2049                } 
     2050 
     2051                priv->chip->setup_port(priv, i, egress, ingress, portmask[i], 
     2052                                       pvid); 
    21352053        } 
    21362054 
     
    25162434        .get_port_pvid = ar8xxx_sw_get_pvid, 
    25172435        .set_port_pvid = ar8xxx_sw_set_pvid, 
    2518         .get_vlan_ports = ar8216_sw_get_ports, 
    2519         .set_vlan_ports = ar8216_sw_set_ports, 
     2436        .get_vlan_ports = ar8xxx_sw_get_ports, 
     2437        .set_vlan_ports = ar8xxx_sw_set_ports, 
    25202438        .apply_config = ar8xxx_sw_hw_apply, 
    25212439        .reset_switch = ar8xxx_sw_reset_switch, 
     
    25382456        .get_port_pvid = ar8xxx_sw_get_pvid, 
    25392457        .set_port_pvid = ar8xxx_sw_set_pvid, 
    2540         .get_vlan_ports = ar8327_sw_get_ports, 
    2541         .set_vlan_ports = ar8327_sw_set_ports, 
     2458        .get_vlan_ports = ar8xxx_sw_get_ports, 
     2459        .set_vlan_ports = ar8xxx_sw_set_ports, 
    25422460        .apply_config = ar8xxx_sw_hw_apply, 
    25432461        .reset_switch = ar8xxx_sw_reset_switch, 
Note: See TracChangeset for help on using the changeset viewer.