Changeset 31008


Ignore:
Timestamp:
2012-03-18T23:06:45+01:00 (6 years ago)
Author:
juhosg
Message:

generic: ar8216: reorder switch_dev specific functions

File:
1 edited

Legend:

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

    r31007 r31008  
    214214 
    215215static int 
    216 ar8216_sw_set_vlan(struct switch_dev *dev, const struct switch_attr *attr, 
    217                    struct switch_val *val) 
    218 { 
    219         struct ar8216_priv *priv = to_ar8216(dev); 
    220         priv->vlan = !!val->value.i; 
    221         return 0; 
    222 } 
    223  
    224 static int 
    225 ar8216_sw_get_vlan(struct switch_dev *dev, const struct switch_attr *attr, 
    226                    struct switch_val *val) 
    227 { 
    228         struct ar8216_priv *priv = to_ar8216(dev); 
    229         val->value.i = priv->vlan; 
    230         return 0; 
    231 } 
    232  
    233  
    234 static int 
    235 ar8216_sw_set_pvid(struct switch_dev *dev, int port, int vlan) 
    236 { 
    237         struct ar8216_priv *priv = to_ar8216(dev); 
    238  
    239         /* make sure no invalid PVIDs get set */ 
    240  
    241         if (vlan >= dev->vlans) 
    242                 return -EINVAL; 
    243  
    244         priv->pvid[port] = vlan; 
    245         return 0; 
    246 } 
    247  
    248 static int 
    249 ar8216_sw_get_pvid(struct switch_dev *dev, int port, int *vlan) 
    250 { 
    251         struct ar8216_priv *priv = to_ar8216(dev); 
    252         *vlan = priv->pvid[port]; 
    253         return 0; 
    254 } 
    255  
    256 static int 
    257 ar8216_sw_set_vid(struct switch_dev *dev, const struct switch_attr *attr, 
    258                   struct switch_val *val) 
    259 { 
    260         struct ar8216_priv *priv = to_ar8216(dev); 
    261         priv->vlan_id[val->port_vlan] = val->value.i; 
    262         return 0; 
    263 } 
    264  
    265 static int 
    266 ar8216_sw_get_vid(struct switch_dev *dev, const struct switch_attr *attr, 
    267                   struct switch_val *val) 
    268 { 
    269         struct ar8216_priv *priv = to_ar8216(dev); 
    270         val->value.i = priv->vlan_id[val->port_vlan]; 
    271         return 0; 
    272 } 
    273  
    274 static int 
    275 ar8216_sw_get_port_link(struct switch_dev *dev, int port, 
    276                         struct switch_port_link *link) 
    277 { 
    278         struct ar8216_priv *priv = to_ar8216(dev); 
    279  
    280         ar8216_read_port_link(priv, port, link); 
    281         return 0; 
    282 } 
    283  
    284 static int 
    285216ar8216_mangle_tx(struct sk_buff *skb, struct net_device *dev) 
    286217{ 
     
    376307{ 
    377308        return ar8216_mangle_rx(skb, 1); 
    378 } 
    379  
    380  
    381 static struct switch_attr ar8216_globals[] = { 
    382         { 
    383                 .type = SWITCH_TYPE_INT, 
    384                 .name = "enable_vlan", 
    385                 .description = "Enable VLAN mode", 
    386                 .set = ar8216_sw_set_vlan, 
    387                 .get = ar8216_sw_get_vlan, 
    388                 .max = 1 
    389         }, 
    390 }; 
    391  
    392 static struct switch_attr ar8216_port[] = { 
    393 }; 
    394  
    395 static struct switch_attr ar8216_vlan[] = { 
    396         { 
    397                 .type = SWITCH_TYPE_INT, 
    398                 .name = "vid", 
    399                 .description = "VLAN ID (0-4094)", 
    400                 .set = ar8216_sw_set_vid, 
    401                 .get = ar8216_sw_get_vid, 
    402                 .max = 4094, 
    403         }, 
    404 }; 
    405  
    406  
    407 static int 
    408 ar8216_sw_get_ports(struct switch_dev *dev, struct switch_val *val) 
    409 { 
    410         struct ar8216_priv *priv = to_ar8216(dev); 
    411         u8 ports = priv->vlan_table[val->port_vlan]; 
    412         int i; 
    413  
    414         val->len = 0; 
    415         for (i = 0; i < dev->ports; i++) { 
    416                 struct switch_port *p; 
    417  
    418                 if (!(ports & (1 << i))) 
    419                         continue; 
    420  
    421                 p = &val->value.ports[val->len++]; 
    422                 p->id = i; 
    423                 if (priv->vlan_tagged & (1 << i)) 
    424                         p->flags = (1 << SWITCH_PORT_FLAG_TAGGED); 
    425                 else 
    426                         p->flags = 0; 
    427         } 
    428         return 0; 
    429 } 
    430  
    431 static int 
    432 ar8216_sw_set_ports(struct switch_dev *dev, struct switch_val *val) 
    433 { 
    434         struct ar8216_priv *priv = to_ar8216(dev); 
    435         u8 *vt = &priv->vlan_table[val->port_vlan]; 
    436         int i, j; 
    437  
    438         *vt = 0; 
    439         for (i = 0; i < val->len; i++) { 
    440                 struct switch_port *p = &val->value.ports[i]; 
    441  
    442                 if (p->flags & (1 << SWITCH_PORT_FLAG_TAGGED)) { 
    443                         priv->vlan_tagged |= (1 << p->id); 
    444                 } else { 
    445                         priv->vlan_tagged &= ~(1 << p->id); 
    446                         priv->pvid[p->id] = val->port_vlan; 
    447  
    448                         /* make sure that an untagged port does not 
    449                          * appear in other vlans */ 
    450                         for (j = 0; j < AR8X16_MAX_VLANS; j++) { 
    451                                 if (j == val->port_vlan) 
    452                                         continue; 
    453                                 priv->vlan_table[j] &= ~(1 << p->id); 
    454                         } 
    455                 } 
    456  
    457                 *vt |= 1 << p->id; 
    458         } 
    459         return 0; 
    460309} 
    461310 
     
    577426                   (ingress << AR8236_PORT_VLAN2_VLAN_MODE_S) | 
    578427                   (members << AR8236_PORT_VLAN2_MEMBER_S)); 
    579 } 
    580  
    581 static int 
    582 ar8216_sw_hw_apply(struct switch_dev *dev) 
    583 { 
    584         struct ar8216_priv *priv = to_ar8216(dev); 
    585         u8 portmask[AR8216_NUM_PORTS]; 
    586         int i, j; 
    587  
    588         mutex_lock(&priv->reg_mutex); 
    589         /* flush all vlan translation unit entries */ 
    590         priv->chip->vtu_flush(priv); 
    591  
    592         memset(portmask, 0, sizeof(portmask)); 
    593         if (!priv->init) { 
    594                 /* calculate the port destination masks and load vlans 
    595                  * into the vlan translation unit */ 
    596                 for (j = 0; j < AR8X16_MAX_VLANS; j++) { 
    597                         u8 vp = priv->vlan_table[j]; 
    598  
    599                         if (!vp) 
    600                                 continue; 
    601  
    602                         for (i = 0; i < dev->ports; i++) { 
    603                                 u8 mask = (1 << i); 
    604                                 if (vp & mask) 
    605                                         portmask[i] |= vp & ~mask; 
    606                         } 
    607  
    608                         priv->chip->vtu_load_vlan(priv, priv->vlan_id[j], 
    609                                                  priv->vlan_table[j]); 
    610                 } 
    611         } else { 
    612                 /* vlan disabled: 
    613                  * isolate all ports, but connect them to the cpu port */ 
    614                 for (i = 0; i < dev->ports; i++) { 
    615                         if (i == AR8216_PORT_CPU) 
    616                                 continue; 
    617  
    618                         portmask[i] = 1 << AR8216_PORT_CPU; 
    619                         portmask[AR8216_PORT_CPU] |= (1 << i); 
    620                 } 
    621         } 
    622  
    623         /* update the port destination mask registers and tag settings */ 
    624         for (i = 0; i < dev->ports; i++) { 
    625                 int egress, ingress; 
    626                 int pvid; 
    627  
    628                 if (priv->vlan) { 
    629                         pvid = priv->vlan_id[priv->pvid[i]]; 
    630                         if (priv->vlan_tagged & (1 << i)) 
    631                                 egress = AR8216_OUT_ADD_VLAN; 
    632                         else 
    633                                 egress = AR8216_OUT_STRIP_VLAN; 
    634                         ingress = AR8216_IN_SECURE; 
    635                 } else { 
    636                         pvid = i; 
    637                         egress = AR8216_OUT_KEEP; 
    638                         ingress = AR8216_IN_PORT_ONLY; 
    639                 } 
    640  
    641                 priv->chip->setup_port(priv, i, egress, ingress, portmask[i], 
    642                                        pvid); 
    643         } 
    644         mutex_unlock(&priv->reg_mutex); 
    645         return 0; 
    646428} 
    647429 
     
    828610 
    829611static int 
     612ar8216_sw_set_vlan(struct switch_dev *dev, const struct switch_attr *attr, 
     613                   struct switch_val *val) 
     614{ 
     615        struct ar8216_priv *priv = to_ar8216(dev); 
     616        priv->vlan = !!val->value.i; 
     617        return 0; 
     618} 
     619 
     620static int 
     621ar8216_sw_get_vlan(struct switch_dev *dev, const struct switch_attr *attr, 
     622                   struct switch_val *val) 
     623{ 
     624        struct ar8216_priv *priv = to_ar8216(dev); 
     625        val->value.i = priv->vlan; 
     626        return 0; 
     627} 
     628 
     629 
     630static int 
     631ar8216_sw_set_pvid(struct switch_dev *dev, int port, int vlan) 
     632{ 
     633        struct ar8216_priv *priv = to_ar8216(dev); 
     634 
     635        /* make sure no invalid PVIDs get set */ 
     636 
     637        if (vlan >= dev->vlans) 
     638                return -EINVAL; 
     639 
     640        priv->pvid[port] = vlan; 
     641        return 0; 
     642} 
     643 
     644static int 
     645ar8216_sw_get_pvid(struct switch_dev *dev, int port, int *vlan) 
     646{ 
     647        struct ar8216_priv *priv = to_ar8216(dev); 
     648        *vlan = priv->pvid[port]; 
     649        return 0; 
     650} 
     651 
     652static int 
     653ar8216_sw_set_vid(struct switch_dev *dev, const struct switch_attr *attr, 
     654                  struct switch_val *val) 
     655{ 
     656        struct ar8216_priv *priv = to_ar8216(dev); 
     657        priv->vlan_id[val->port_vlan] = val->value.i; 
     658        return 0; 
     659} 
     660 
     661static int 
     662ar8216_sw_get_vid(struct switch_dev *dev, const struct switch_attr *attr, 
     663                  struct switch_val *val) 
     664{ 
     665        struct ar8216_priv *priv = to_ar8216(dev); 
     666        val->value.i = priv->vlan_id[val->port_vlan]; 
     667        return 0; 
     668} 
     669 
     670static int 
     671ar8216_sw_get_port_link(struct switch_dev *dev, int port, 
     672                        struct switch_port_link *link) 
     673{ 
     674        struct ar8216_priv *priv = to_ar8216(dev); 
     675 
     676        ar8216_read_port_link(priv, port, link); 
     677        return 0; 
     678} 
     679 
     680static int 
     681ar8216_sw_get_ports(struct switch_dev *dev, struct switch_val *val) 
     682{ 
     683        struct ar8216_priv *priv = to_ar8216(dev); 
     684        u8 ports = priv->vlan_table[val->port_vlan]; 
     685        int i; 
     686 
     687        val->len = 0; 
     688        for (i = 0; i < dev->ports; i++) { 
     689                struct switch_port *p; 
     690 
     691                if (!(ports & (1 << i))) 
     692                        continue; 
     693 
     694                p = &val->value.ports[val->len++]; 
     695                p->id = i; 
     696                if (priv->vlan_tagged & (1 << i)) 
     697                        p->flags = (1 << SWITCH_PORT_FLAG_TAGGED); 
     698                else 
     699                        p->flags = 0; 
     700        } 
     701        return 0; 
     702} 
     703 
     704static int 
     705ar8216_sw_set_ports(struct switch_dev *dev, struct switch_val *val) 
     706{ 
     707        struct ar8216_priv *priv = to_ar8216(dev); 
     708        u8 *vt = &priv->vlan_table[val->port_vlan]; 
     709        int i, j; 
     710 
     711        *vt = 0; 
     712        for (i = 0; i < val->len; i++) { 
     713                struct switch_port *p = &val->value.ports[i]; 
     714 
     715                if (p->flags & (1 << SWITCH_PORT_FLAG_TAGGED)) { 
     716                        priv->vlan_tagged |= (1 << p->id); 
     717                } else { 
     718                        priv->vlan_tagged &= ~(1 << p->id); 
     719                        priv->pvid[p->id] = val->port_vlan; 
     720 
     721                        /* make sure that an untagged port does not 
     722                         * appear in other vlans */ 
     723                        for (j = 0; j < AR8X16_MAX_VLANS; j++) { 
     724                                if (j == val->port_vlan) 
     725                                        continue; 
     726                                priv->vlan_table[j] &= ~(1 << p->id); 
     727                        } 
     728                } 
     729 
     730                *vt |= 1 << p->id; 
     731        } 
     732        return 0; 
     733} 
     734 
     735static int 
     736ar8216_sw_hw_apply(struct switch_dev *dev) 
     737{ 
     738        struct ar8216_priv *priv = to_ar8216(dev); 
     739        u8 portmask[AR8216_NUM_PORTS]; 
     740        int i, j; 
     741 
     742        mutex_lock(&priv->reg_mutex); 
     743        /* flush all vlan translation unit entries */ 
     744        priv->chip->vtu_flush(priv); 
     745 
     746        memset(portmask, 0, sizeof(portmask)); 
     747        if (!priv->init) { 
     748                /* calculate the port destination masks and load vlans 
     749                 * into the vlan translation unit */ 
     750                for (j = 0; j < AR8X16_MAX_VLANS; j++) { 
     751                        u8 vp = priv->vlan_table[j]; 
     752 
     753                        if (!vp) 
     754                                continue; 
     755 
     756                        for (i = 0; i < dev->ports; i++) { 
     757                                u8 mask = (1 << i); 
     758                                if (vp & mask) 
     759                                        portmask[i] |= vp & ~mask; 
     760                        } 
     761 
     762                        priv->chip->vtu_load_vlan(priv, priv->vlan_id[j], 
     763                                                 priv->vlan_table[j]); 
     764                } 
     765        } else { 
     766                /* vlan disabled: 
     767                 * isolate all ports, but connect them to the cpu port */ 
     768                for (i = 0; i < dev->ports; i++) { 
     769                        if (i == AR8216_PORT_CPU) 
     770                                continue; 
     771 
     772                        portmask[i] = 1 << AR8216_PORT_CPU; 
     773                        portmask[AR8216_PORT_CPU] |= (1 << i); 
     774                } 
     775        } 
     776 
     777        /* update the port destination mask registers and tag settings */ 
     778        for (i = 0; i < dev->ports; i++) { 
     779                int egress, ingress; 
     780                int pvid; 
     781 
     782                if (priv->vlan) { 
     783                        pvid = priv->vlan_id[priv->pvid[i]]; 
     784                        if (priv->vlan_tagged & (1 << i)) 
     785                                egress = AR8216_OUT_ADD_VLAN; 
     786                        else 
     787                                egress = AR8216_OUT_STRIP_VLAN; 
     788                        ingress = AR8216_IN_SECURE; 
     789                } else { 
     790                        pvid = i; 
     791                        egress = AR8216_OUT_KEEP; 
     792                        ingress = AR8216_IN_PORT_ONLY; 
     793                } 
     794 
     795                priv->chip->setup_port(priv, i, egress, ingress, portmask[i], 
     796                                       pvid); 
     797        } 
     798        mutex_unlock(&priv->reg_mutex); 
     799        return 0; 
     800} 
     801 
     802static int 
    830803ar8216_sw_reset_switch(struct switch_dev *dev) 
    831804{ 
     
    849822        return ar8216_sw_hw_apply(dev); 
    850823} 
     824 
     825static struct switch_attr ar8216_globals[] = { 
     826        { 
     827                .type = SWITCH_TYPE_INT, 
     828                .name = "enable_vlan", 
     829                .description = "Enable VLAN mode", 
     830                .set = ar8216_sw_set_vlan, 
     831                .get = ar8216_sw_get_vlan, 
     832                .max = 1 
     833        }, 
     834}; 
     835 
     836static struct switch_attr ar8216_port[] = { 
     837}; 
     838 
     839static struct switch_attr ar8216_vlan[] = { 
     840        { 
     841                .type = SWITCH_TYPE_INT, 
     842                .name = "vid", 
     843                .description = "VLAN ID (0-4094)", 
     844                .set = ar8216_sw_set_vid, 
     845                .get = ar8216_sw_get_vid, 
     846                .max = 4094, 
     847        }, 
     848}; 
    851849 
    852850static const struct switch_dev_ops ar8216_sw_ops = { 
Note: See TracChangeset for help on using the changeset viewer.