To be aligned with obj.
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Scott Feldman <sfeldma@gmail.com>
Reviewed-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
 ^^^^^^^^^
 
 The switchdev driver must implement the switchdev op switchdev_port_attr_get
-for SWITCHDEV_ATTR_PORT_PARENT_ID for each port netdev, returning the same
+for SWITCHDEV_ATTR_ID_PORT_PARENT_ID for each port netdev, returning the same
 physical ID for each port of a switch.  The ID must be unique between switches
 on the same system.  The ID does not need to be unique between switches on
 different systems.
 device port and on the bridge port, and disable learning_sync.
 
 To support learning and learning_sync port attributes, the driver implements
-switchdev op switchdev_port_attr_get/set for SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS.
-The driver should initialize the attributes to the hardware defaults.
+switchdev op switchdev_port_attr_get/set for
+SWITCHDEV_ATTR_PORT_ID_BRIDGE_FLAGS. The driver should initialize the attributes
+to the hardware defaults.
 
 FDB Ageing
 ^^^^^^^^^^
 Internally or with a third-party STP protocol implementation (e.g. mstpd), the
 bridge driver maintains the STP state for ports, and will notify the switch
 driver of STP state change on a port using the switchdev op
-switchdev_attr_port_set for SWITCHDEV_ATTR_PORT_STP_UPDATE.
+switchdev_attr_port_set for SWITCHDEV_ATTR_PORT_ID_STP_UPDATE.
 
 State is one of BR_STATE_*.  The switch driver can use STP state updates to
 update ingress packet filter list for the port.  For example, if port is
 
        struct mlxsw_sx *mlxsw_sx = mlxsw_sx_port->mlxsw_sx;
 
        switch (attr->id) {
-       case SWITCHDEV_ATTR_PORT_PARENT_ID:
+       case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
                attr->u.ppid.id_len = sizeof(mlxsw_sx->hw_id);
                memcpy(&attr->u.ppid.id, &mlxsw_sx->hw_id, attr->u.ppid.id_len);
                break;
 
        const struct rocker *rocker = rocker_port->rocker;
 
        switch (attr->id) {
-       case SWITCHDEV_ATTR_PORT_PARENT_ID:
+       case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
                attr->u.ppid.id_len = sizeof(rocker->hw.id);
                memcpy(&attr->u.ppid.id, &rocker->hw.id, attr->u.ppid.id_len);
                break;
-       case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS:
+       case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
                attr->u.brport_flags = rocker_port->brport_flags;
                break;
        default:
        int err = 0;
 
        switch (attr->id) {
-       case SWITCHDEV_ATTR_PORT_STP_STATE:
+       case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
                err = rocker_port_stp_update(rocker_port, trans,
                                             ROCKER_OP_FLAG_NOWAIT,
                                             attr->u.stp_state);
                break;
-       case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS:
+       case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
                err = rocker_port_brport_flags_set(rocker_port, trans,
                                                   attr->u.brport_flags);
                break;
 
 }
 
 enum switchdev_attr_id {
-       SWITCHDEV_ATTR_UNDEFINED,
-       SWITCHDEV_ATTR_PORT_PARENT_ID,
-       SWITCHDEV_ATTR_PORT_STP_STATE,
-       SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+       SWITCHDEV_ATTR_ID_UNDEFINED,
+       SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
+       SWITCHDEV_ATTR_ID_PORT_STP_STATE,
+       SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS,
 };
 
 struct switchdev_attr {
 
 void br_set_state(struct net_bridge_port *p, unsigned int state)
 {
        struct switchdev_attr attr = {
-               .id = SWITCHDEV_ATTR_PORT_STP_STATE,
+               .id = SWITCHDEV_ATTR_ID_PORT_STP_STATE,
                .u.stp_state = state,
        };
        int err;
 
 
        if (dev_isalive(netdev)) {
                struct switchdev_attr attr = {
-                       .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+                       .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
                        .flags = SWITCHDEV_F_NO_RECURSE,
                };
 
 
 {
        int err;
        struct switchdev_attr attr = {
-               .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+               .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
                .flags = SWITCHDEV_F_NO_RECURSE,
        };
 
 
        int ret;
 
        switch (attr->id) {
-       case SWITCHDEV_ATTR_PORT_STP_STATE:
+       case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
                if (switchdev_trans_ph_prepare(trans))
                        ret = ds->drv->port_stp_update ? 0 : -EOPNOTSUPP;
                else
        struct dsa_switch *ds = p->parent;
 
        switch (attr->id) {
-       case SWITCHDEV_ATTR_PORT_PARENT_ID:
+       case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
                attr->u.ppid.id_len = sizeof(ds->index);
                memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
                break;
 
        struct net_device *lower_dev;
        struct list_head *iter;
        struct switchdev_attr first = {
-               .id = SWITCHDEV_ATTR_UNDEFINED
+               .id = SWITCHDEV_ATTR_ID_UNDEFINED
        };
        int err = -EOPNOTSUPP;
 
                err = switchdev_port_attr_get(lower_dev, attr);
                if (err)
                        break;
-               if (first.id == SWITCHDEV_ATTR_UNDEFINED)
+               if (first.id == SWITCHDEV_ATTR_ID_UNDEFINED)
                        first = *attr;
                else if (memcmp(&first, attr, sizeof(*attr)))
                        return -ENODATA;
                                  int nlflags)
 {
        struct switchdev_attr attr = {
-               .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+               .id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS,
        };
        u16 mode = BRIDGE_MODE_UNDEF;
        u32 mask = BR_LEARNING | BR_LEARNING_SYNC;
                                     unsigned long brport_flag)
 {
        struct switchdev_attr attr = {
-               .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+               .id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS,
        };
        u8 flag = nla_get_u8(nlattr);
        int err;
 static struct net_device *switchdev_get_dev_by_nhs(struct fib_info *fi)
 {
        struct switchdev_attr attr = {
-               .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+               .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
        };
        struct switchdev_attr prev_attr;
        struct net_device *dev = NULL;
                                          struct net_device *b)
 {
        struct switchdev_attr a_attr = {
-               .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+               .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
                .flags = SWITCHDEV_F_NO_RECURSE,
        };
        struct switchdev_attr b_attr = {
-               .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+               .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
                .flags = SWITCHDEV_F_NO_RECURSE,
        };