microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge branch 'mlxsw-next' 

Jiri Pirko says:

====================
mlxsw: small driver update + one tiny devlink dependency

Cosmetics, in preparation to sharedbuffer patchset.
First patch is here to allow patch number two.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2016-04-08 15:38:43 -04:00
Родитель 24d390b2ac 9efc8f655c
Коммит 67b5b21f38
8 изменённых файлов: 114 добавлений и 113 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

56
drivers/net/ethernet/mellanox/mlxsw/core.c
Просмотреть файл

@ -114,6 +114,12 @@ struct mlxsw_core {
/* driver_priv has to be always the last item */ /* driver_priv has to be always the last item */
}; };
void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core)
{
return mlxsw_core->driver_priv;
}
EXPORT_SYMBOL(mlxsw_core_driver_priv);
struct mlxsw_rx_listener_item { struct mlxsw_rx_listener_item {
struct list_head list; struct list_head list;
struct mlxsw_rx_listener rxl; struct mlxsw_rx_listener rxl;
@ -381,7 +387,7 @@ static int __mlxsw_emad_transmit(struct mlxsw_core *mlxsw_core,
mlxsw_core->emad.trans_active = true; mlxsw_core->emad.trans_active = true;
err = mlxsw_core_skb_transmit(mlxsw_core->driver_priv, skb, tx_info); err = mlxsw_core_skb_transmit(mlxsw_core, skb, tx_info);
if (err) { if (err) {
dev_err(mlxsw_core->bus_info->dev, "Failed to transmit EMAD (tid=%llx)\n", dev_err(mlxsw_core->bus_info->dev, "Failed to transmit EMAD (tid=%llx)\n",
mlxsw_core->emad.tid); mlxsw_core->emad.tid);
@ -795,8 +801,7 @@ static int mlxsw_devlink_port_split(struct devlink *devlink,
return -EINVAL; return -EINVAL;
if (!mlxsw_core->driver->port_split) if (!mlxsw_core->driver->port_split)
return -EOPNOTSUPP; return -EOPNOTSUPP;
return mlxsw_core->driver->port_split(mlxsw_core->driver_priv, return mlxsw_core->driver->port_split(mlxsw_core, port_index, count);
port_index, count);
} }
static int mlxsw_devlink_port_unsplit(struct devlink *devlink, static int mlxsw_devlink_port_unsplit(struct devlink *devlink,
@ -808,8 +813,7 @@ static int mlxsw_devlink_port_unsplit(struct devlink *devlink,
return -EINVAL; return -EINVAL;
if (!mlxsw_core->driver->port_unsplit) if (!mlxsw_core->driver->port_unsplit)
return -EOPNOTSUPP; return -EOPNOTSUPP;
return mlxsw_core->driver->port_unsplit(mlxsw_core->driver_priv, return mlxsw_core->driver->port_unsplit(mlxsw_core, port_index);
port_index);
} }
static const struct devlink_ops mlxsw_devlink_ops = { static const struct devlink_ops mlxsw_devlink_ops = {
@ -880,8 +884,7 @@ int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
if (err) if (err)
goto err_devlink_register; goto err_devlink_register;
err = mlxsw_driver->init(mlxsw_core->driver_priv, mlxsw_core, err = mlxsw_driver->init(mlxsw_core, mlxsw_bus_info);
mlxsw_bus_info);
if (err) if (err)
goto err_driver_init; goto err_driver_init;
@ -892,7 +895,7 @@ int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
return 0; return 0;
err_debugfs_init: err_debugfs_init:
mlxsw_core->driver->fini(mlxsw_core->driver_priv); mlxsw_core->driver->fini(mlxsw_core);
err_driver_init: err_driver_init:
devlink_unregister(devlink); devlink_unregister(devlink);
err_devlink_register: err_devlink_register:
@ -918,7 +921,7 @@ void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core)
struct devlink *devlink = priv_to_devlink(mlxsw_core); struct devlink *devlink = priv_to_devlink(mlxsw_core);
mlxsw_core_debugfs_fini(mlxsw_core); mlxsw_core_debugfs_fini(mlxsw_core);
mlxsw_core->driver->fini(mlxsw_core->driver_priv); mlxsw_core->driver->fini(mlxsw_core);
devlink_unregister(devlink); devlink_unregister(devlink);
mlxsw_emad_fini(mlxsw_core); mlxsw_emad_fini(mlxsw_core);
mlxsw_core->bus->fini(mlxsw_core->bus_priv); mlxsw_core->bus->fini(mlxsw_core->bus_priv);
@ -929,26 +932,17 @@ void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core)
} }
EXPORT_SYMBOL(mlxsw_core_bus_device_unregister); EXPORT_SYMBOL(mlxsw_core_bus_device_unregister);
static struct mlxsw_core *__mlxsw_core_get(void *driver_priv) bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core,
{
return container_of(driver_priv, struct mlxsw_core, driver_priv);
}
bool mlxsw_core_skb_transmit_busy(void *driver_priv,
const struct mlxsw_tx_info *tx_info) const struct mlxsw_tx_info *tx_info)
{ {
struct mlxsw_core *mlxsw_core = __mlxsw_core_get(driver_priv);
return mlxsw_core->bus->skb_transmit_busy(mlxsw_core->bus_priv, return mlxsw_core->bus->skb_transmit_busy(mlxsw_core->bus_priv,
tx_info); tx_info);
} }
EXPORT_SYMBOL(mlxsw_core_skb_transmit_busy); EXPORT_SYMBOL(mlxsw_core_skb_transmit_busy);
int mlxsw_core_skb_transmit(void *driver_priv, struct sk_buff *skb, int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
const struct mlxsw_tx_info *tx_info) const struct mlxsw_tx_info *tx_info)
{ {
struct mlxsw_core *mlxsw_core = __mlxsw_core_get(driver_priv);
return mlxsw_core->bus->skb_transmit(mlxsw_core->bus_priv, skb, return mlxsw_core->bus->skb_transmit(mlxsw_core->bus_priv, skb,
tx_info); tx_info);
} }
@ -1358,6 +1352,28 @@ void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
} }
EXPORT_SYMBOL(mlxsw_core_lag_mapping_clear); EXPORT_SYMBOL(mlxsw_core_lag_mapping_clear);
int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core,
struct mlxsw_core_port *mlxsw_core_port, u8 local_port,
struct net_device *dev, bool split, u32 split_group)
{
struct devlink *devlink = priv_to_devlink(mlxsw_core);
struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;
if (split)
devlink_port_split_set(devlink_port, split_group);
devlink_port_type_eth_set(devlink_port, dev);
return devlink_port_register(devlink, devlink_port, local_port);
}
EXPORT_SYMBOL(mlxsw_core_port_init);
void mlxsw_core_port_fini(struct mlxsw_core_port *mlxsw_core_port)
{
struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;
devlink_port_unregister(devlink_port);
}
EXPORT_SYMBOL(mlxsw_core_port_fini);
int mlxsw_cmd_exec(struct mlxsw_core *mlxsw_core, u16 opcode, u8 opcode_mod, int mlxsw_cmd_exec(struct mlxsw_core *mlxsw_core, u16 opcode, u8 opcode_mod,
u32 in_mod, bool out_mbox_direct, u32 in_mod, bool out_mbox_direct,
char *in_mbox, size_t in_mbox_size, char *in_mbox, size_t in_mbox_size,

26
drivers/net/ethernet/mellanox/mlxsw/core.h
Просмотреть файл

@ -43,6 +43,7 @@
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include <net/devlink.h>
#include "trap.h" #include "trap.h"
#include "reg.h" #include "reg.h"
@ -61,6 +62,8 @@ struct mlxsw_driver;
struct mlxsw_bus; struct mlxsw_bus;
struct mlxsw_bus_info; struct mlxsw_bus_info;
void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core);
int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver); int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver);
void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver); void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver);
@ -74,10 +77,9 @@ struct mlxsw_tx_info {
bool is_emad; bool is_emad;
}; };
bool mlxsw_core_skb_transmit_busy(void *driver_priv, bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core,
const struct mlxsw_tx_info *tx_info); const struct mlxsw_tx_info *tx_info);
int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
int mlxsw_core_skb_transmit(void *driver_priv, struct sk_buff *skb,
const struct mlxsw_tx_info *tx_info); const struct mlxsw_tx_info *tx_info);
struct mlxsw_rx_listener { struct mlxsw_rx_listener {
@ -131,6 +133,15 @@ u8 mlxsw_core_lag_mapping_get(struct mlxsw_core *mlxsw_core,
void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core, void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
u16 lag_id, u8 local_port); u16 lag_id, u8 local_port);
struct mlxsw_core_port {
struct devlink_port devlink_port;
};
int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core,
struct mlxsw_core_port *mlxsw_core_port, u8 local_port,
struct net_device *dev, bool split, u32 split_group);
void mlxsw_core_port_fini(struct mlxsw_core_port *mlxsw_core_port);
#define MLXSW_CONFIG_PROFILE_SWID_COUNT 8 #define MLXSW_CONFIG_PROFILE_SWID_COUNT 8
struct mlxsw_swid_config { struct mlxsw_swid_config {
@ -183,11 +194,12 @@ struct mlxsw_driver {
const char *kind; const char *kind;
struct module *owner; struct module *owner;
size_t priv_size; size_t priv_size;
int (*init)(void *driver_priv, struct mlxsw_core *mlxsw_core, int (*init)(struct mlxsw_core *mlxsw_core,
const struct mlxsw_bus_info *mlxsw_bus_info); const struct mlxsw_bus_info *mlxsw_bus_info);
void (*fini)(void *driver_priv); void (*fini)(struct mlxsw_core *mlxsw_core);
int (*port_split)(void *driver_priv, u8 local_port, unsigned int count); int (*port_split)(struct mlxsw_core *mlxsw_core, u8 local_port,
int (*port_unsplit)(void *driver_priv, u8 local_port); unsigned int count);
int (*port_unsplit)(struct mlxsw_core *mlxsw_core, u8 local_port);
void (*txhdr_construct)(struct sk_buff *skb, void (*txhdr_construct)(struct sk_buff *skb,
const struct mlxsw_tx_info *tx_info); const struct mlxsw_tx_info *tx_info);
u8 txhdr_len; u8 txhdr_len;

27
drivers/net/ethernet/mellanox/mlxsw/reg.h
Просмотреть файл

@ -3476,9 +3476,10 @@ static const struct mlxsw_reg_info mlxsw_reg_sbpr = {
.len = MLXSW_REG_SBPR_LEN, .len = MLXSW_REG_SBPR_LEN,
}; };
enum mlxsw_reg_sbpr_dir { /* shared direstion enum for SBPR, SBCM, SBPM */
MLXSW_REG_SBPR_DIR_INGRESS, enum mlxsw_reg_sbxx_dir {
MLXSW_REG_SBPR_DIR_EGRESS, MLXSW_REG_SBXX_DIR_INGRESS,
MLXSW_REG_SBXX_DIR_EGRESS,
}; };
/* reg_sbpr_dir /* reg_sbpr_dir
@ -3511,7 +3512,7 @@ enum mlxsw_reg_sbpr_mode {
MLXSW_ITEM32(reg, sbpr, mode, 0x08, 0, 4); MLXSW_ITEM32(reg, sbpr, mode, 0x08, 0, 4);
static inline void mlxsw_reg_sbpr_pack(char *payload, u8 pool, static inline void mlxsw_reg_sbpr_pack(char *payload, u8 pool,
enum mlxsw_reg_sbpr_dir dir, enum mlxsw_reg_sbxx_dir dir,
enum mlxsw_reg_sbpr_mode mode, u32 size) enum mlxsw_reg_sbpr_mode mode, u32 size)
{ {
MLXSW_REG_ZERO(sbpr, payload); MLXSW_REG_ZERO(sbpr, payload);
@ -3553,11 +3554,6 @@ MLXSW_ITEM32(reg, sbcm, local_port, 0x00, 16, 8);
*/ */
MLXSW_ITEM32(reg, sbcm, pg_buff, 0x00, 8, 6); MLXSW_ITEM32(reg, sbcm, pg_buff, 0x00, 8, 6);
enum mlxsw_reg_sbcm_dir {
MLXSW_REG_SBCM_DIR_INGRESS,
MLXSW_REG_SBCM_DIR_EGRESS,
};
/* reg_sbcm_dir /* reg_sbcm_dir
* Direction. * Direction.
* Access: Index * Access: Index
@ -3590,7 +3586,7 @@ MLXSW_ITEM32(reg, sbcm, max_buff, 0x1C, 0, 24);
MLXSW_ITEM32(reg, sbcm, pool, 0x24, 0, 4); MLXSW_ITEM32(reg, sbcm, pool, 0x24, 0, 4);
static inline void mlxsw_reg_sbcm_pack(char *payload, u8 local_port, u8 pg_buff, static inline void mlxsw_reg_sbcm_pack(char *payload, u8 local_port, u8 pg_buff,
enum mlxsw_reg_sbcm_dir dir, enum mlxsw_reg_sbxx_dir dir,
u32 min_buff, u32 max_buff, u8 pool) u32 min_buff, u32 max_buff, u8 pool)
{ {
MLXSW_REG_ZERO(sbcm, payload); MLXSW_REG_ZERO(sbcm, payload);
@ -3602,8 +3598,8 @@ static inline void mlxsw_reg_sbcm_pack(char *payload, u8 local_port, u8 pg_buff,
mlxsw_reg_sbcm_pool_set(payload, pool); mlxsw_reg_sbcm_pool_set(payload, pool);
} }
/* SBPM - Shared Buffer Class Management Register /* SBPM - Shared Buffer Port Management Register
* ---------------------------------------------- * ---------------------------------------------
* The SBPM register configures and retrieves the shared buffer allocation * The SBPM register configures and retrieves the shared buffer allocation
* and configuration according to Port-Pool, including the definition * and configuration according to Port-Pool, including the definition
* of the associated quota. * of the associated quota.
@ -3630,11 +3626,6 @@ MLXSW_ITEM32(reg, sbpm, local_port, 0x00, 16, 8);
*/ */
MLXSW_ITEM32(reg, sbpm, pool, 0x00, 8, 4); MLXSW_ITEM32(reg, sbpm, pool, 0x00, 8, 4);
enum mlxsw_reg_sbpm_dir {
MLXSW_REG_SBPM_DIR_INGRESS,
MLXSW_REG_SBPM_DIR_EGRESS,
};
/* reg_sbpm_dir /* reg_sbpm_dir
* Direction. * Direction.
* Access: Index * Access: Index
@ -3661,7 +3652,7 @@ MLXSW_ITEM32(reg, sbpm, min_buff, 0x18, 0, 24);
MLXSW_ITEM32(reg, sbpm, max_buff, 0x1C, 0, 24); MLXSW_ITEM32(reg, sbpm, max_buff, 0x1C, 0, 24);
static inline void mlxsw_reg_sbpm_pack(char *payload, u8 local_port, u8 pool, static inline void mlxsw_reg_sbpm_pack(char *payload, u8 local_port, u8 pool,
enum mlxsw_reg_sbpm_dir dir, enum mlxsw_reg_sbxx_dir dir,
u32 min_buff, u32 max_buff) u32 min_buff, u32 max_buff)
{ {
MLXSW_REG_ZERO(sbpm, payload); MLXSW_REG_ZERO(sbpm, payload);

52
drivers/net/ethernet/mellanox/mlxsw/spectrum.c
Просмотреть файл

@ -50,7 +50,6 @@
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/list.h> #include <linux/list.h>
#include <linux/dcbnl.h> #include <linux/dcbnl.h>
#include <net/devlink.h>
#include <net/switchdev.h> #include <net/switchdev.h>
#include <generated/utsrelease.h> #include <generated/utsrelease.h>
@ -391,7 +390,7 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
u64 len; u64 len;
int err; int err;
if (mlxsw_core_skb_transmit_busy(mlxsw_sp, &tx_info)) if (mlxsw_core_skb_transmit_busy(mlxsw_sp->core, &tx_info))
return NETDEV_TX_BUSY; return NETDEV_TX_BUSY;
if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) { if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
@ -415,7 +414,7 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
/* Due to a race we might fail here because of a full queue. In that /* Due to a race we might fail here because of a full queue. In that
* unlikely case we simply drop the packet. * unlikely case we simply drop the packet.
*/ */
err = mlxsw_core_skb_transmit(mlxsw_sp, skb, &tx_info); err = mlxsw_core_skb_transmit(mlxsw_sp->core, skb, &tx_info);
if (!err) { if (!err) {
pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats); pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats);
@ -1685,9 +1684,7 @@ static int mlxsw_sp_port_ets_init(struct mlxsw_sp_port *mlxsw_sp_port)
static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port, static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
bool split, u8 module, u8 width) bool split, u8 module, u8 width)
{ {
struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
struct mlxsw_sp_port *mlxsw_sp_port; struct mlxsw_sp_port *mlxsw_sp_port;
struct devlink_port *devlink_port;
struct net_device *dev; struct net_device *dev;
size_t bytes; size_t bytes;
int err; int err;
@ -1740,16 +1737,6 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
*/ */
dev->hard_header_len += MLXSW_TXHDR_LEN; dev->hard_header_len += MLXSW_TXHDR_LEN;
devlink_port = &mlxsw_sp_port->devlink_port;
if (mlxsw_sp_port->split)
devlink_port_split_set(devlink_port, module);
err = devlink_port_register(devlink, devlink_port, local_port);
if (err) {
dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to register devlink port\n",
mlxsw_sp_port->local_port);
goto err_devlink_port_register;
}
err = mlxsw_sp_port_system_port_mapping_set(mlxsw_sp_port); err = mlxsw_sp_port_system_port_mapping_set(mlxsw_sp_port);
if (err) { if (err) {
dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set system port mapping\n", dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set system port mapping\n",
@ -1812,7 +1799,14 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
goto err_register_netdev; goto err_register_netdev;
} }
devlink_port_type_eth_set(devlink_port, dev); err = mlxsw_core_port_init(mlxsw_sp->core, &mlxsw_sp_port->core_port,
mlxsw_sp_port->local_port, dev,
mlxsw_sp_port->split, module);
if (err) {
dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to init core port\n",
mlxsw_sp_port->local_port);
goto err_core_port_init;
}
err = mlxsw_sp_port_vlan_init(mlxsw_sp_port); err = mlxsw_sp_port_vlan_init(mlxsw_sp_port);
if (err) if (err)
@ -1822,6 +1816,8 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
return 0; return 0;
err_port_vlan_init: err_port_vlan_init:
mlxsw_core_port_fini(&mlxsw_sp_port->core_port);
err_core_port_init:
unregister_netdev(dev); unregister_netdev(dev);
err_register_netdev: err_register_netdev:
err_port_dcb_init: err_port_dcb_init:
@ -1832,8 +1828,6 @@ err_port_mtu_set:
err_port_speed_by_width_set: err_port_speed_by_width_set:
err_port_swid_set: err_port_swid_set:
err_port_system_port_mapping_set: err_port_system_port_mapping_set:
devlink_port_unregister(&mlxsw_sp_port->devlink_port);
err_devlink_port_register:
err_dev_addr_init: err_dev_addr_init:
free_percpu(mlxsw_sp_port->pcpu_stats); free_percpu(mlxsw_sp_port->pcpu_stats);
err_alloc_stats: err_alloc_stats:
@ -1887,16 +1881,13 @@ static void mlxsw_sp_port_vports_fini(struct mlxsw_sp_port *mlxsw_sp_port)
static void mlxsw_sp_port_remove(struct mlxsw_sp *mlxsw_sp, u8 local_port) static void mlxsw_sp_port_remove(struct mlxsw_sp *mlxsw_sp, u8 local_port)
{ {
struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp->ports[local_port]; struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp->ports[local_port];
struct devlink_port *devlink_port;
if (!mlxsw_sp_port) if (!mlxsw_sp_port)
return; return;
mlxsw_sp->ports[local_port] = NULL; mlxsw_sp->ports[local_port] = NULL;
devlink_port = &mlxsw_sp_port->devlink_port; mlxsw_core_port_fini(&mlxsw_sp_port->core_port);
devlink_port_type_clear(devlink_port);
unregister_netdev(mlxsw_sp_port->dev); /* This calls ndo_stop */ unregister_netdev(mlxsw_sp_port->dev); /* This calls ndo_stop */
mlxsw_sp_port_dcb_fini(mlxsw_sp_port); mlxsw_sp_port_dcb_fini(mlxsw_sp_port);
devlink_port_unregister(devlink_port);
mlxsw_sp_port_vports_fini(mlxsw_sp_port); mlxsw_sp_port_vports_fini(mlxsw_sp_port);
mlxsw_sp_port_switchdev_fini(mlxsw_sp_port); mlxsw_sp_port_switchdev_fini(mlxsw_sp_port);
mlxsw_sp_port_swid_set(mlxsw_sp_port, MLXSW_PORT_SWID_DISABLED_PORT); mlxsw_sp_port_swid_set(mlxsw_sp_port, MLXSW_PORT_SWID_DISABLED_PORT);
@ -1957,9 +1948,10 @@ static u8 mlxsw_sp_cluster_base_port_get(u8 local_port)
return local_port - offset; return local_port - offset;
} }
static int mlxsw_sp_port_split(void *priv, u8 local_port, unsigned int count) static int mlxsw_sp_port_split(struct mlxsw_core *mlxsw_core, u8 local_port,
unsigned int count)
{ {
struct mlxsw_sp *mlxsw_sp = priv; struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
struct mlxsw_sp_port *mlxsw_sp_port; struct mlxsw_sp_port *mlxsw_sp_port;
u8 width = MLXSW_PORT_MODULE_MAX_WIDTH / count; u8 width = MLXSW_PORT_MODULE_MAX_WIDTH / count;
u8 module, cur_width, base_port; u8 module, cur_width, base_port;
@ -2031,9 +2023,9 @@ err_port_create:
return err; return err;
} }
static int mlxsw_sp_port_unsplit(void *priv, u8 local_port) static int mlxsw_sp_port_unsplit(struct mlxsw_core *mlxsw_core, u8 local_port)
{ {
struct mlxsw_sp *mlxsw_sp = priv; struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
struct mlxsw_sp_port *mlxsw_sp_port; struct mlxsw_sp_port *mlxsw_sp_port;
u8 module, cur_width, base_port; u8 module, cur_width, base_port;
unsigned int count; unsigned int count;
@ -2378,10 +2370,10 @@ static int mlxsw_sp_lag_init(struct mlxsw_sp *mlxsw_sp)
return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcr), slcr_pl); return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcr), slcr_pl);
} }
static int mlxsw_sp_init(void *priv, struct mlxsw_core *mlxsw_core, static int mlxsw_sp_init(struct mlxsw_core *mlxsw_core,
const struct mlxsw_bus_info *mlxsw_bus_info) const struct mlxsw_bus_info *mlxsw_bus_info)
{ {
struct mlxsw_sp *mlxsw_sp = priv; struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
int err; int err;
mlxsw_sp->core = mlxsw_core; mlxsw_sp->core = mlxsw_core;
@ -2452,9 +2444,9 @@ err_event_register:
return err; return err;
} }
static void mlxsw_sp_fini(void *priv) static void mlxsw_sp_fini(struct mlxsw_core *mlxsw_core)
{ {
struct mlxsw_sp *mlxsw_sp = priv; struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
mlxsw_sp_switchdev_fini(mlxsw_sp); mlxsw_sp_switchdev_fini(mlxsw_sp);
mlxsw_sp_traps_fini(mlxsw_sp); mlxsw_sp_traps_fini(mlxsw_sp);

3
drivers/net/ethernet/mellanox/mlxsw/spectrum.h
Просмотреть файл

@ -44,7 +44,6 @@
#include <linux/list.h> #include <linux/list.h>
#include <linux/dcbnl.h> #include <linux/dcbnl.h>
#include <net/switchdev.h> #include <net/switchdev.h>
#include <net/devlink.h>
#include "port.h" #include "port.h"
#include "core.h" #include "core.h"
@ -166,6 +165,7 @@ struct mlxsw_sp_port_pcpu_stats {
}; };
struct mlxsw_sp_port { struct mlxsw_sp_port {
struct mlxsw_core_port core_port; /* must be first */
struct net_device *dev; struct net_device *dev;
struct mlxsw_sp_port_pcpu_stats __percpu *pcpu_stats; struct mlxsw_sp_port_pcpu_stats __percpu *pcpu_stats;
struct mlxsw_sp *mlxsw_sp; struct mlxsw_sp *mlxsw_sp;
@ -198,7 +198,6 @@ struct mlxsw_sp_port {
unsigned long *untagged_vlans; unsigned long *untagged_vlans;
/* VLAN interfaces */ /* VLAN interfaces */
struct list_head vports_list; struct list_head vports_list;
struct devlink_port devlink_port;
}; };
static inline bool static inline bool

20
drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
Просмотреть файл

@ -110,7 +110,7 @@ static int mlxsw_sp_port_headroom_init(struct mlxsw_sp_port *mlxsw_sp_port)
struct mlxsw_sp_sb_pool { struct mlxsw_sp_sb_pool {
u8 pool; u8 pool;
enum mlxsw_reg_sbpr_dir dir; enum mlxsw_reg_sbxx_dir dir;
enum mlxsw_reg_sbpr_mode mode; enum mlxsw_reg_sbpr_mode mode;
u32 size; u32 size;
}; };
@ -129,11 +129,11 @@ struct mlxsw_sp_sb_pool {
} }
#define MLXSW_SP_SB_POOL_INGRESS(_pool, _size) \ #define MLXSW_SP_SB_POOL_INGRESS(_pool, _size) \
MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBPR_DIR_INGRESS, \ MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBXX_DIR_INGRESS, \
MLXSW_REG_SBPR_MODE_DYNAMIC, _size) MLXSW_REG_SBPR_MODE_DYNAMIC, _size)
#define MLXSW_SP_SB_POOL_EGRESS(_pool, _size) \ #define MLXSW_SP_SB_POOL_EGRESS(_pool, _size) \
MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBPR_DIR_EGRESS, \ MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBXX_DIR_EGRESS, \
MLXSW_REG_SBPR_MODE_DYNAMIC, _size) MLXSW_REG_SBPR_MODE_DYNAMIC, _size)
static const struct mlxsw_sp_sb_pool mlxsw_sp_sb_pools[] = { static const struct mlxsw_sp_sb_pool mlxsw_sp_sb_pools[] = {
@ -173,7 +173,7 @@ struct mlxsw_sp_sb_cm {
u8 pg; u8 pg;
u8 tc; u8 tc;
} u; } u;
enum mlxsw_reg_sbcm_dir dir; enum mlxsw_reg_sbxx_dir dir;
u32 min_buff; u32 min_buff;
u32 max_buff; u32 max_buff;
u8 pool; u8 pool;
@ -189,15 +189,15 @@ struct mlxsw_sp_sb_cm {
} }
#define MLXSW_SP_SB_CM_INGRESS(_pg, _min_buff, _max_buff) \ #define MLXSW_SP_SB_CM_INGRESS(_pg, _min_buff, _max_buff) \
MLXSW_SP_SB_CM(_pg, MLXSW_REG_SBCM_DIR_INGRESS, \ MLXSW_SP_SB_CM(_pg, MLXSW_REG_SBXX_DIR_INGRESS, \
_min_buff, _max_buff, 0) _min_buff, _max_buff, 0)
#define MLXSW_SP_SB_CM_EGRESS(_tc, _min_buff, _max_buff) \ #define MLXSW_SP_SB_CM_EGRESS(_tc, _min_buff, _max_buff) \
MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBCM_DIR_EGRESS, \ MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBXX_DIR_EGRESS, \
_min_buff, _max_buff, 0) _min_buff, _max_buff, 0)
#define MLXSW_SP_CPU_PORT_SB_CM_EGRESS(_tc) \ #define MLXSW_SP_CPU_PORT_SB_CM_EGRESS(_tc) \
MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBCM_DIR_EGRESS, 104, 2, 3) MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBXX_DIR_EGRESS, 104, 2, 3)
static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms[] = { static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms[] = {
MLXSW_SP_SB_CM_INGRESS(0, MLXSW_SP_BYTES_TO_CELLS(10000), 8), MLXSW_SP_SB_CM_INGRESS(0, MLXSW_SP_BYTES_TO_CELLS(10000), 8),
@ -304,7 +304,7 @@ static int mlxsw_sp_cpu_port_sb_cms_init(struct mlxsw_sp *mlxsw_sp)
struct mlxsw_sp_sb_pm { struct mlxsw_sp_sb_pm {
u8 pool; u8 pool;
enum mlxsw_reg_sbpm_dir dir; enum mlxsw_reg_sbxx_dir dir;
u32 min_buff; u32 min_buff;
u32 max_buff; u32 max_buff;
}; };
@ -318,11 +318,11 @@ struct mlxsw_sp_sb_pm {
} }
#define MLXSW_SP_SB_PM_INGRESS(_pool, _min_buff, _max_buff) \ #define MLXSW_SP_SB_PM_INGRESS(_pool, _min_buff, _max_buff) \
MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBPM_DIR_INGRESS, \ MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBXX_DIR_INGRESS, \
_min_buff, _max_buff) _min_buff, _max_buff)
#define MLXSW_SP_SB_PM_EGRESS(_pool, _min_buff, _max_buff) \ #define MLXSW_SP_SB_PM_EGRESS(_pool, _min_buff, _max_buff) \
MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBPM_DIR_EGRESS, \ MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBXX_DIR_EGRESS, \
_min_buff, _max_buff) _min_buff, _max_buff)
static const struct mlxsw_sp_sb_pm mlxsw_sp_sb_pms[] = { static const struct mlxsw_sp_sb_pm mlxsw_sp_sb_pms[] = {

42
drivers/net/ethernet/mellanox/mlxsw/switchx2.c
Просмотреть файл

@ -43,7 +43,6 @@
#include <linux/device.h> #include <linux/device.h>
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include <linux/if_vlan.h> #include <linux/if_vlan.h>
#include <net/devlink.h>
#include <net/switchdev.h> #include <net/switchdev.h>
#include <generated/utsrelease.h> #include <generated/utsrelease.h>
@ -75,11 +74,11 @@ struct mlxsw_sx_port_pcpu_stats {
}; };
struct mlxsw_sx_port { struct mlxsw_sx_port {
struct mlxsw_core_port core_port; /* must be first */
struct net_device *dev; struct net_device *dev;
struct mlxsw_sx_port_pcpu_stats __percpu *pcpu_stats; struct mlxsw_sx_port_pcpu_stats __percpu *pcpu_stats;
struct mlxsw_sx *mlxsw_sx; struct mlxsw_sx *mlxsw_sx;
u8 local_port; u8 local_port;
struct devlink_port devlink_port;
}; };
/* tx_hdr_version /* tx_hdr_version
@ -303,7 +302,7 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
u64 len; u64 len;
int err; int err;
if (mlxsw_core_skb_transmit_busy(mlxsw_sx, &tx_info)) if (mlxsw_core_skb_transmit_busy(mlxsw_sx->core, &tx_info))
return NETDEV_TX_BUSY; return NETDEV_TX_BUSY;
if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) { if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
@ -321,7 +320,7 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
/* Due to a race we might fail here because of a full queue. In that /* Due to a race we might fail here because of a full queue. In that
* unlikely case we simply drop the packet. * unlikely case we simply drop the packet.
*/ */
err = mlxsw_core_skb_transmit(mlxsw_sx, skb, &tx_info); err = mlxsw_core_skb_transmit(mlxsw_sx->core, skb, &tx_info);
if (!err) { if (!err) {
pcpu_stats = this_cpu_ptr(mlxsw_sx_port->pcpu_stats); pcpu_stats = this_cpu_ptr(mlxsw_sx_port->pcpu_stats);
@ -956,9 +955,7 @@ mlxsw_sx_port_mac_learning_mode_set(struct mlxsw_sx_port *mlxsw_sx_port,
static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port) static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
{ {
struct devlink *devlink = priv_to_devlink(mlxsw_sx->core);
struct mlxsw_sx_port *mlxsw_sx_port; struct mlxsw_sx_port *mlxsw_sx_port;
struct devlink_port *devlink_port;
struct net_device *dev; struct net_device *dev;
bool usable; bool usable;
int err; int err;
@ -1012,14 +1009,6 @@ static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
goto port_not_usable; goto port_not_usable;
} }
devlink_port = &mlxsw_sx_port->devlink_port;
err = devlink_port_register(devlink, devlink_port, local_port);
if (err) {
dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to register devlink port\n",
mlxsw_sx_port->local_port);
goto err_devlink_port_register;
}
err = mlxsw_sx_port_system_port_mapping_set(mlxsw_sx_port); err = mlxsw_sx_port_system_port_mapping_set(mlxsw_sx_port);
if (err) { if (err) {
dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to set system port mapping\n", dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to set system port mapping\n",
@ -1077,11 +1066,19 @@ static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
goto err_register_netdev; goto err_register_netdev;
} }
devlink_port_type_eth_set(devlink_port, dev); err = mlxsw_core_port_init(mlxsw_sx->core, &mlxsw_sx_port->core_port,
mlxsw_sx_port->local_port, dev, false, 0);
if (err) {
dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to init core port\n",
mlxsw_sx_port->local_port);
goto err_core_port_init;
}
mlxsw_sx->ports[local_port] = mlxsw_sx_port; mlxsw_sx->ports[local_port] = mlxsw_sx_port;
return 0; return 0;
err_core_port_init:
unregister_netdev(dev);
err_register_netdev: err_register_netdev:
err_port_mac_learning_mode_set: err_port_mac_learning_mode_set:
err_port_stp_state_set: err_port_stp_state_set:
@ -1090,8 +1087,6 @@ err_port_mtu_set:
err_port_speed_set: err_port_speed_set:
err_port_swid_set: err_port_swid_set:
err_port_system_port_mapping_set: err_port_system_port_mapping_set:
devlink_port_unregister(&mlxsw_sx_port->devlink_port);
err_devlink_port_register:
port_not_usable: port_not_usable:
err_port_module_check: err_port_module_check:
err_dev_addr_get: err_dev_addr_get:
@ -1104,15 +1099,12 @@ err_alloc_stats:
static void mlxsw_sx_port_remove(struct mlxsw_sx *mlxsw_sx, u8 local_port) static void mlxsw_sx_port_remove(struct mlxsw_sx *mlxsw_sx, u8 local_port)
{ {
struct mlxsw_sx_port *mlxsw_sx_port = mlxsw_sx->ports[local_port]; struct mlxsw_sx_port *mlxsw_sx_port = mlxsw_sx->ports[local_port];
struct devlink_port *devlink_port;
if (!mlxsw_sx_port) if (!mlxsw_sx_port)
return; return;
devlink_port = &mlxsw_sx_port->devlink_port; mlxsw_core_port_fini(&mlxsw_sx_port->core_port);
devlink_port_type_clear(devlink_port);
unregister_netdev(mlxsw_sx_port->dev); /* This calls ndo_stop */ unregister_netdev(mlxsw_sx_port->dev); /* This calls ndo_stop */
mlxsw_sx_port_swid_set(mlxsw_sx_port, MLXSW_PORT_SWID_DISABLED_PORT); mlxsw_sx_port_swid_set(mlxsw_sx_port, MLXSW_PORT_SWID_DISABLED_PORT);
devlink_port_unregister(devlink_port);
free_percpu(mlxsw_sx_port->pcpu_stats); free_percpu(mlxsw_sx_port->pcpu_stats);
free_netdev(mlxsw_sx_port->dev); free_netdev(mlxsw_sx_port->dev);
} }
@ -1455,10 +1447,10 @@ static int mlxsw_sx_flood_init(struct mlxsw_sx *mlxsw_sx)
return mlxsw_reg_write(mlxsw_sx->core, MLXSW_REG(sgcr), sgcr_pl); return mlxsw_reg_write(mlxsw_sx->core, MLXSW_REG(sgcr), sgcr_pl);
} }
static int mlxsw_sx_init(void *priv, struct mlxsw_core *mlxsw_core, static int mlxsw_sx_init(struct mlxsw_core *mlxsw_core,
const struct mlxsw_bus_info *mlxsw_bus_info) const struct mlxsw_bus_info *mlxsw_bus_info)
{ {
struct mlxsw_sx *mlxsw_sx = priv; struct mlxsw_sx *mlxsw_sx = mlxsw_core_driver_priv(mlxsw_core);
int err; int err;
mlxsw_sx->core = mlxsw_core; mlxsw_sx->core = mlxsw_core;
@ -1505,9 +1497,9 @@ err_event_register:
return err; return err;
} }
static void mlxsw_sx_fini(void *priv) static void mlxsw_sx_fini(struct mlxsw_core *mlxsw_core)
{ {
struct mlxsw_sx *mlxsw_sx = priv; struct mlxsw_sx *mlxsw_sx = mlxsw_core_driver_priv(mlxsw_core);
mlxsw_sx_traps_fini(mlxsw_sx); mlxsw_sx_traps_fini(mlxsw_sx);
mlxsw_sx_event_unregister(mlxsw_sx, MLXSW_TRAP_ID_PUDE); mlxsw_sx_event_unregister(mlxsw_sx, MLXSW_TRAP_ID_PUDE);

1
net/core/devlink.c
Просмотреть файл

@ -630,7 +630,6 @@ int devlink_port_register(struct devlink *devlink,
} }
devlink_port->devlink = devlink; devlink_port->devlink = devlink;
devlink_port->index = port_index; devlink_port->index = port_index;
devlink_port->type = DEVLINK_PORT_TYPE_NOTSET;
devlink_port->registered = true; devlink_port->registered = true;
list_add_tail(&devlink_port->list, &devlink->port_list); list_add_tail(&devlink_port->list, &devlink->port_list);
mutex_unlock(&devlink_port_mutex); mutex_unlock(&devlink_port_mutex);