return err;
        j = 0;
        for (; i < rif_count; i++) {
-               if (!mlxsw_sp->rifs[i])
+               struct mlxsw_sp_rif *rif = mlxsw_sp_rif_by_index(mlxsw_sp, i);
+
+               if (!rif)
                        continue;
-               err = mlxsw_sp_erif_entry_get(mlxsw_sp, &entry,
-                                             mlxsw_sp->rifs[i],
+               err = mlxsw_sp_erif_entry_get(mlxsw_sp, &entry, rif,
                                              counters_enabled);
                if (err)
                        goto err_entry_get;
 
        rtnl_lock();
        for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
-               if (!mlxsw_sp->rifs[i])
+               struct mlxsw_sp_rif *rif = mlxsw_sp_rif_by_index(mlxsw_sp, i);
+
+               if (!rif)
                        continue;
                if (enable)
-                       mlxsw_sp_rif_counter_alloc(mlxsw_sp,
-                                                  mlxsw_sp->rifs[i],
+                       mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif,
                                                   MLXSW_SP_RIF_COUNTER_EGRESS);
                else
-                       mlxsw_sp_rif_counter_free(mlxsw_sp,
-                                                 mlxsw_sp->rifs[i],
+                       mlxsw_sp_rif_counter_free(mlxsw_sp, rif,
                                                  MLXSW_SP_RIF_COUNTER_EGRESS);
        }
        rtnl_unlock();
 
 
 struct mlxsw_sp_router {
        struct mlxsw_sp *mlxsw_sp;
+       struct mlxsw_sp_rif **rifs;
        struct mlxsw_sp_vr *vrs;
        struct rhashtable neigh_ht;
        struct rhashtable nexthop_group_ht;
 
        mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
 
-       if (!mlxsw_sp->rifs[rif]) {
+       if (!mlxsw_sp->router->rifs[rif]) {
                dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
                return;
        }
 
        dipn = htonl(dip);
-       dev = mlxsw_sp->rifs[rif]->dev;
+       dev = mlxsw_sp->router->rifs[rif]->dev;
        n = neigh_lookup(&arp_tbl, &dipn, dev);
        if (!n) {
                netdev_err(dev, "Failed to find matching neighbour for IP=%pI4h\n",
        int i;
 
        for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
-               if (mlxsw_sp->rifs[i] && mlxsw_sp->rifs[i]->dev == dev)
-                       return mlxsw_sp->rifs[i];
+               if (mlxsw_sp->router->rifs[i] &&
+                   mlxsw_sp->router->rifs[i]->dev == dev)
+                       return mlxsw_sp->router->rifs[i];
 
        return NULL;
 }
        int i;
 
        for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
-               if (!mlxsw_sp->rifs[i])
+               if (!mlxsw_sp->router->rifs[i])
                        return i;
 
        return MLXSW_SP_INVALID_INDEX_RIF;
        return rif;
 }
 
+struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
+                                          u16 rif_index)
+{
+       return mlxsw_sp->router->rifs[rif_index];
+}
+
 u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
 {
        return rif->rif_index;
        }
 
        f->rif = rif;
-       mlxsw_sp->rifs[rif_index] = rif;
+       mlxsw_sp->router->rifs[rif_index] = rif;
        vr->rif_count++;
 
        return rif;
        mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_INGRESS);
 
        vr->rif_count--;
-       mlxsw_sp->rifs[rif_index] = NULL;
+       mlxsw_sp->router->rifs[rif_index] = NULL;
        f->rif = NULL;
 
        kfree(rif);
        }
 
        f->rif = rif;
-       mlxsw_sp->rifs[rif_index] = rif;
+       mlxsw_sp->router->rifs[rif_index] = rif;
        vr->rif_count++;
 
        netdev_dbg(l3_dev, "RIF=%d created\n", rif_index);
        mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
 
        vr->rif_count--;
-       mlxsw_sp->rifs[rif_index] = NULL;
+       mlxsw_sp->router->rifs[rif_index] = NULL;
        f->rif = NULL;
 
        kfree(rif);
                return -EIO;
 
        max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
-       mlxsw_sp->rifs = kcalloc(max_rifs, sizeof(struct mlxsw_sp_rif *),
-                                GFP_KERNEL);
-       if (!mlxsw_sp->rifs)
+       mlxsw_sp->router->rifs = kcalloc(max_rifs,
+                                        sizeof(struct mlxsw_sp_rif *),
+                                        GFP_KERNEL);
+       if (!mlxsw_sp->router->rifs)
                return -ENOMEM;
 
        mlxsw_reg_rgcr_pack(rgcr_pl, true);
        return 0;
 
 err_rgcr_fail:
-       kfree(mlxsw_sp->rifs);
+       kfree(mlxsw_sp->router->rifs);
        return err;
 }
 
        mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
 
        for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
-               WARN_ON_ONCE(mlxsw_sp->rifs[i]);
+               WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
 
-       kfree(mlxsw_sp->rifs);
+       kfree(mlxsw_sp->router->rifs);
 }
 
 int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)