iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mlxsw: core: Extend port module data structures for line cards

Browse Source 
The port module core is tasked with module operations such as setting
power mode policy and reset. The per-module information is currently
stored in one large array suited for non-modular systems where only the
main board is present (i.e., slot index 0).

As a preparation for line cards support, allocate a per line card array
according to the queried number of slots in the system. For each line
card, allocate a module array according to the queried maximum number of
modules per-slot.

Signed-off-by: Vadim Pasternak <vadimp@nvidia.com>
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Vadim Pasternak 2022-04-13 18:17:26 +03:00 committed by David S. Miller
parent 349454526f
commit e5b6a5bac8
1 changed files with 169 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

242
drivers/net/ethernet/mellanox/mlxsw/core_env.c
View File

@ -21,20 +21,36 @@ struct mlxsw_env_module_info {
enum mlxsw_reg_pmtm_module_type type;
};
struct mlxsw_env {
struct mlxsw_core *core;
struct mlxsw_env_line_card {
u8 module_count;
struct mutex module_info_lock; /* Protects 'module_info'. */
struct mlxsw_env_module_info module_info[];
};
struct mlxsw_env {
struct mlxsw_core *core;
u8 max_module_count; /* Maximum number of modules per-slot. */
u8 num_of_slots; /* Including the main board. */
struct mutex line_cards_lock; /* Protects line cards. */
struct mlxsw_env_line_card *line_cards[];
};
static struct
mlxsw_env_module_info *mlxsw_env_module_info_get(struct mlxsw_core *mlxsw_core,
u8 slot_index, u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
return &mlxsw_env->line_cards[slot_index]->module_info[module];
}
static int __mlxsw_env_validate_module_type(struct mlxsw_core *core,
u8 slot_index, u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(core);
struct mlxsw_env_module_info *module_info;
int err;
switch (mlxsw_env->module_info[module].type) {
module_info = mlxsw_env_module_info_get(core, slot_index, module);
switch (module_info->type) {
case MLXSW_REG_PMTM_MODULE_TYPE_TWISTED_PAIR:
err = -EINVAL;
break;
@ -51,9 +67,9 @@ static int mlxsw_env_validate_module_type(struct mlxsw_core *core,
struct mlxsw_env *mlxsw_env = mlxsw_core_env(core);
int err;
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
err = __mlxsw_env_validate_module_type(core, slot_index, module);
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
return err;
}
@ -472,6 +488,7 @@ int mlxsw_env_reset_module(struct net_device *netdev,
u8 module, u32 *flags)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
u32 req = *flags;
int err;
@ -479,7 +496,7 @@ int mlxsw_env_reset_module(struct net_device *netdev,
!(req & (ETH_RESET_PHY << ETH_RESET_SHARED_SHIFT)))
return 0;
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
err = __mlxsw_env_validate_module_type(mlxsw_core, slot_index, module);
if (err) {
@ -487,13 +504,14 @@ int mlxsw_env_reset_module(struct net_device *netdev,
goto out;
}
if (mlxsw_env->module_info[module].num_ports_up) {
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
if (module_info->num_ports_up) {
netdev_err(netdev, "Cannot reset module when ports using it are administratively up\n");
err = -EINVAL;
goto out;
}
if (mlxsw_env->module_info[module].num_ports_mapped > 1 &&
if (module_info->num_ports_mapped > 1 &&
!(req & (ETH_RESET_PHY << ETH_RESET_SHARED_SHIFT))) {
netdev_err(netdev, "Cannot reset module without \"phy-shared\" flag when shared by multiple ports\n");
err = -EINVAL;
@ -509,7 +527,7 @@ int mlxsw_env_reset_module(struct net_device *netdev,
*flags &= ~(ETH_RESET_PHY | (ETH_RESET_PHY << ETH_RESET_SHARED_SHIFT));
out:
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
return err;
}
EXPORT_SYMBOL(mlxsw_env_reset_module);
@ -521,11 +539,12 @@ mlxsw_env_get_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
struct netlink_ext_ack *extack)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
char mcion_pl[MLXSW_REG_MCION_LEN];
u32 status_bits;
int err;
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
err = __mlxsw_env_validate_module_type(mlxsw_core, slot_index, module);
if (err) {
@ -533,7 +552,8 @@ mlxsw_env_get_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
goto out;
}
params->policy = mlxsw_env->module_info[module].power_mode_policy;
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
params->policy = module_info->power_mode_policy;
mlxsw_reg_mcion_pack(mcion_pl, slot_index, module);
err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcion), mcion_pl);
@ -552,7 +572,7 @@ mlxsw_env_get_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
params->mode = ETHTOOL_MODULE_POWER_MODE_HIGH;
out:
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
return err;
}
EXPORT_SYMBOL(mlxsw_env_get_module_power_mode);
@ -634,6 +654,7 @@ mlxsw_env_set_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
struct netlink_ext_ack *extack)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
bool low_power;
int err = 0;
@ -643,7 +664,7 @@ mlxsw_env_set_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
return -EOPNOTSUPP;
}
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
err = __mlxsw_env_validate_module_type(mlxsw_core, slot_index, module);
if (err) {
@ -652,11 +673,12 @@ mlxsw_env_set_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
goto out;
}
if (mlxsw_env->module_info[module].power_mode_policy == policy)
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
if (module_info->power_mode_policy == policy)
goto out;
/* If any ports are up, we are already in high power mode. */
if (mlxsw_env->module_info[module].num_ports_up)
if (module_info->num_ports_up)
goto out_set_policy;
low_power = policy == ETHTOOL_MODULE_POWER_MODE_POLICY_AUTO;
@ -666,9 +688,9 @@ mlxsw_env_set_module_power_mode(struct mlxsw_core *mlxsw_core, u8 slot_index,
goto out;
out_set_policy:
mlxsw_env->module_info[module].power_mode_policy = policy;
module_info->power_mode_policy = policy;
out:
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
return err;
}
EXPORT_SYMBOL(mlxsw_env_set_module_power_mode);
@ -748,10 +770,11 @@ mlxsw_env_temp_event_set(struct mlxsw_core *mlxsw_core, u8 slot_index,
static int mlxsw_env_module_temp_event_enable(struct mlxsw_core *mlxsw_core,
u8 slot_index)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
int i, err, sensor_index;
bool has_temp_sensor;
for (i = 0; i < mlxsw_core_env(mlxsw_core)->module_count; i++) {
for (i = 0; i < mlxsw_env->line_cards[slot_index]->module_count; i++) {
err = mlxsw_env_module_has_temp_sensor(mlxsw_core, slot_index,
i, &has_temp_sensor);
if (err)
@ -779,6 +802,7 @@ struct mlxsw_env_module_temp_warn_event {
static void mlxsw_env_mtwe_event_work(struct work_struct *work)
{
struct mlxsw_env_module_temp_warn_event *event;
struct mlxsw_env_module_info *module_info;
struct mlxsw_env *mlxsw_env;
int i, sensor_warning;
bool is_overheat;
@ -787,7 +811,7 @@ static void mlxsw_env_mtwe_event_work(struct work_struct *work)
work);
mlxsw_env = event->mlxsw_env;
for (i = 0; i < mlxsw_env->module_count; i++) {
for (i = 0; i < mlxsw_env->max_module_count; i++) {
/* 64-127 of sensor_index are mapped to the port modules
* sequentially (module 0 is mapped to sensor_index 64,
* module 1 to sensor_index 65 and so on)
@ -795,9 +819,10 @@ static void mlxsw_env_mtwe_event_work(struct work_struct *work)
sensor_warning =
mlxsw_reg_mtwe_sensor_warning_get(event->mtwe_pl,
i + MLXSW_REG_MTMP_MODULE_INDEX_MIN);
mutex_lock(&mlxsw_env->module_info_lock);
is_overheat =
mlxsw_env->module_info[i].is_overheat;
mutex_lock(&mlxsw_env->line_cards_lock);
/* MTWE only supports main board. */
module_info = mlxsw_env_module_info_get(mlxsw_env->core, 0, i);
is_overheat = module_info->is_overheat;
if ((is_overheat && sensor_warning) ||
(!is_overheat && !sensor_warning)) {
@ -805,21 +830,21 @@ static void mlxsw_env_mtwe_event_work(struct work_struct *work)
* warning OR current state in "no warning" and MTWE
* does not report warning.
*/
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
continue;
} else if (is_overheat && !sensor_warning) {
/* MTWE reports "no warning", turn is_overheat off.
*/
mlxsw_env->module_info[i].is_overheat = false;
mutex_unlock(&mlxsw_env->module_info_lock);
module_info->is_overheat = false;
mutex_unlock(&mlxsw_env->line_cards_lock);
} else {
/* Current state is "no warning" and MTWE reports
* "warning", increase the counter and turn is_overheat
* on.
*/
mlxsw_env->module_info[i].is_overheat = true;
mlxsw_env->module_info[i].module_overheat_counter++;
mutex_unlock(&mlxsw_env->module_info_lock);
module_info->is_overheat = true;
module_info->module_overheat_counter++;
mutex_unlock(&mlxsw_env->line_cards_lock);
}
}
@ -871,6 +896,7 @@ struct mlxsw_env_module_plug_unplug_event {
static void mlxsw_env_pmpe_event_work(struct work_struct *work)
{
struct mlxsw_env_module_plug_unplug_event *event;
struct mlxsw_env_module_info *module_info;
struct mlxsw_env *mlxsw_env;
bool has_temp_sensor;
u16 sensor_index;
@ -880,9 +906,12 @@ static void mlxsw_env_pmpe_event_work(struct work_struct *work)
work);
mlxsw_env = event->mlxsw_env;
mutex_lock(&mlxsw_env->module_info_lock);
mlxsw_env->module_info[event->module].is_overheat = false;
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
module_info = mlxsw_env_module_info_get(mlxsw_env->core,
event->slot_index,
event->module);
module_info->is_overheat = false;
mutex_unlock(&mlxsw_env->line_cards_lock);
err = mlxsw_env_module_has_temp_sensor(mlxsw_env->core,
event->slot_index,
@ -909,12 +938,14 @@ static void
mlxsw_env_pmpe_listener_func(const struct mlxsw_reg_info *reg, char *pmpe_pl,
void *priv)
{
u8 slot_index = mlxsw_reg_pmpe_slot_index_get(pmpe_pl);
struct mlxsw_env_module_plug_unplug_event *event;
enum mlxsw_reg_pmpe_module_status module_status;
u8 module = mlxsw_reg_pmpe_module_get(pmpe_pl);
struct mlxsw_env *mlxsw_env = priv;
if (WARN_ON_ONCE(module >= mlxsw_env->module_count))
if (WARN_ON_ONCE(module >= mlxsw_env->max_module_count ||
slot_index >= mlxsw_env->num_of_slots))
return;
module_status = mlxsw_reg_pmpe_module_status_get(pmpe_pl);
@ -926,7 +957,7 @@ mlxsw_env_pmpe_listener_func(const struct mlxsw_reg_info *reg, char *pmpe_pl,
return;
event->mlxsw_env = mlxsw_env;
event->slot_index = 0;
event->slot_index = slot_index;
event->module = module;
INIT_WORK(&event->work, mlxsw_env_pmpe_event_work);
mlxsw_core_schedule_work(&event->work);
@ -957,9 +988,10 @@ static int
mlxsw_env_module_oper_state_event_enable(struct mlxsw_core *mlxsw_core,
u8 slot_index)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
int i, err;
for (i = 0; i < mlxsw_core_env(mlxsw_core)->module_count; i++) {
for (i = 0; i < mlxsw_env->line_cards[slot_index]->module_count; i++) {
char pmaos_pl[MLXSW_REG_PMAOS_LEN];
mlxsw_reg_pmaos_pack(pmaos_pl, slot_index, i);
@ -978,10 +1010,12 @@ mlxsw_env_module_overheat_counter_get(struct mlxsw_core *mlxsw_core, u8 slot_ind
u8 module, u64 *p_counter)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
mutex_lock(&mlxsw_env->module_info_lock);
*p_counter = mlxsw_env->module_info[module].module_overheat_counter;
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
*p_counter = module_info->module_overheat_counter;
mutex_unlock(&mlxsw_env->line_cards_lock);
return 0;
}
@ -991,10 +1025,12 @@ void mlxsw_env_module_port_map(struct mlxsw_core *mlxsw_core, u8 slot_index,
u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
mutex_lock(&mlxsw_env->module_info_lock);
mlxsw_env->module_info[module].num_ports_mapped++;
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
module_info->num_ports_mapped++;
mutex_unlock(&mlxsw_env->line_cards_lock);
}
EXPORT_SYMBOL(mlxsw_env_module_port_map);
@ -1002,10 +1038,12 @@ void mlxsw_env_module_port_unmap(struct mlxsw_core *mlxsw_core, u8 slot_index,
u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
mutex_lock(&mlxsw_env->module_info_lock);
mlxsw_env->module_info[module].num_ports_mapped--;
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
module_info->num_ports_mapped--;
mutex_unlock(&mlxsw_env->line_cards_lock);
}
EXPORT_SYMBOL(mlxsw_env_module_port_unmap);
@ -1013,15 +1051,17 @@ int mlxsw_env_module_port_up(struct mlxsw_core *mlxsw_core, u8 slot_index,
u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
int err = 0;
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
if (mlxsw_env->module_info[module].power_mode_policy !=
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
if (module_info->power_mode_policy !=
ETHTOOL_MODULE_POWER_MODE_POLICY_AUTO)
goto out_inc;
if (mlxsw_env->module_info[module].num_ports_up != 0)
if (module_info->num_ports_up != 0)
goto out_inc;
/* Transition to high power mode following first port using the module
@ -1033,9 +1073,9 @@ int mlxsw_env_module_port_up(struct mlxsw_core *mlxsw_core, u8 slot_index,
goto out_unlock;
out_inc:
mlxsw_env->module_info[module].num_ports_up++;
module_info->num_ports_up++;
out_unlock:
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
return err;
}
EXPORT_SYMBOL(mlxsw_env_module_port_up);
@ -1044,16 +1084,18 @@ void mlxsw_env_module_port_down(struct mlxsw_core *mlxsw_core, u8 slot_index,
u8 module)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
struct mlxsw_env_module_info *module_info;
mutex_lock(&mlxsw_env->module_info_lock);
mutex_lock(&mlxsw_env->line_cards_lock);
mlxsw_env->module_info[module].num_ports_up--;
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index, module);
module_info->num_ports_up--;
if (mlxsw_env->module_info[module].power_mode_policy !=
if (module_info->power_mode_policy !=
ETHTOOL_MODULE_POWER_MODE_POLICY_AUTO)
goto out_unlock;
if (mlxsw_env->module_info[module].num_ports_up != 0)
if (module_info->num_ports_up != 0)
goto out_unlock;
/* Transition to low power mode following last port using the module
@ -1063,17 +1105,57 @@ void mlxsw_env_module_port_down(struct mlxsw_core *mlxsw_core, u8 slot_index,
NULL);
out_unlock:
mutex_unlock(&mlxsw_env->module_info_lock);
mutex_unlock(&mlxsw_env->line_cards_lock);
}
EXPORT_SYMBOL(mlxsw_env_module_port_down);
static int mlxsw_env_line_cards_alloc(struct mlxsw_env *env)
{
struct mlxsw_env_module_info *module_info;
int i, j;
for (i = 0; i < env->num_of_slots; i++) {
env->line_cards[i] = kzalloc(struct_size(env->line_cards[i],
module_info,
env->max_module_count),
GFP_KERNEL);
if (!env->line_cards[i])
goto kzalloc_err;
/* Firmware defaults to high power mode policy where modules
* are transitioned to high power mode following plug-in.
*/
for (j = 0; j < env->max_module_count; j++) {
module_info = &env->line_cards[i]->module_info[j];
module_info->power_mode_policy =
ETHTOOL_MODULE_POWER_MODE_POLICY_HIGH;
}
}
return 0;
kzalloc_err:
for (i--; i >= 0; i--)
kfree(env->line_cards[i]);
return -ENOMEM;
}
static void mlxsw_env_line_cards_free(struct mlxsw_env *env)
{
int i = env->num_of_slots;
for (i--; i >= 0; i--)
kfree(env->line_cards[i]);
}
static int
mlxsw_env_module_type_set(struct mlxsw_core *mlxsw_core, u8 slot_index)
{
struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
int i;
for (i = 0; i < mlxsw_env->module_count; i++) {
for (i = 0; i < mlxsw_env->line_cards[slot_index]->module_count; i++) {
struct mlxsw_env_module_info *module_info;
char pmtm_pl[MLXSW_REG_PMTM_LEN];
int err;
@ -1082,8 +1164,9 @@ mlxsw_env_module_type_set(struct mlxsw_core *mlxsw_core, u8 slot_index)
if (err)
return err;
mlxsw_env->module_info[i].type =
mlxsw_reg_pmtm_module_type_get(pmtm_pl);
module_info = mlxsw_env_module_info_get(mlxsw_core, slot_index,
i);
module_info->type = mlxsw_reg_pmtm_module_type_get(pmtm_pl);
}
return 0;
@ -1091,32 +1174,38 @@ mlxsw_env_module_type_set(struct mlxsw_core *mlxsw_core, u8 slot_index)
int mlxsw_env_init(struct mlxsw_core *mlxsw_core, struct mlxsw_env **p_env)
{
u8 module_count, num_of_slots, max_module_count;
char mgpir_pl[MLXSW_REG_MGPIR_LEN];
struct mlxsw_env *env;
u8 module_count;
int i, err;
int err;
mlxsw_reg_mgpir_pack(mgpir_pl, 0);
err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mgpir), mgpir_pl);
if (err)
return err;
mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, &module_count, NULL);
mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, &module_count,
&num_of_slots);
/* If the system is modular, get the maximum number of modules per-slot.
* Otherwise, get the maximum number of modules on the main board.
*/
max_module_count = num_of_slots ?
mlxsw_reg_mgpir_max_modules_per_slot_get(mgpir_pl) :
module_count;
env = kzalloc(struct_size(env, module_info, module_count), GFP_KERNEL);
env = kzalloc(struct_size(env, line_cards, num_of_slots + 1),
GFP_KERNEL);
if (!env)
return -ENOMEM;
/* Firmware defaults to high power mode policy where modules are
* transitioned to high power mode following plug-in.
*/
for (i = 0; i < module_count; i++)
env->module_info[i].power_mode_policy =
ETHTOOL_MODULE_POWER_MODE_POLICY_HIGH;
mutex_init(&env->module_info_lock);
env->core = mlxsw_core;
env->module_count = module_count;
env->num_of_slots = num_of_slots + 1;
env->max_module_count = max_module_count;
err = mlxsw_env_line_cards_alloc(env);
if (err)
goto err_mlxsw_env_line_cards_alloc;
mutex_init(&env->line_cards_lock);
*p_env = env;
err = mlxsw_env_temp_warn_event_register(mlxsw_core);
@ -1127,6 +1216,10 @@ int mlxsw_env_init(struct mlxsw_core *mlxsw_core, struct mlxsw_env **p_env)
if (err)
goto err_module_plug_event_register;
/* Set 'module_count' only for main board. Actual count for line card
* is to be set after line card is activated.
*/
env->line_cards[0]->module_count = num_of_slots ? 0 : module_count;
err = mlxsw_env_module_oper_state_event_enable(mlxsw_core, 0);
if (err)
goto err_oper_state_event_enable;
@ -1148,7 +1241,9 @@ err_oper_state_event_enable:
err_module_plug_event_register:
mlxsw_env_temp_warn_event_unregister(env);
err_temp_warn_event_register:
mutex_destroy(&env->module_info_lock);
mutex_destroy(&env->line_cards_lock);
mlxsw_env_line_cards_free(env);
err_mlxsw_env_line_cards_alloc:
kfree(env);
return err;
}
@ -1159,6 +1254,7 @@ void mlxsw_env_fini(struct mlxsw_env *env)
/* Make sure there is no more event work scheduled. */
mlxsw_core_flush_owq();
mlxsw_env_temp_warn_event_unregister(env);
mutex_destroy(&env->module_info_lock);
mutex_destroy(&env->line_cards_lock);
mlxsw_env_line_cards_free(env);
kfree(env);
}