Commit 79e08823 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'mlxsw-hwmon-and-thermal-extensions' 



Ido Schimmel says:

====================
mlxsw: hwmon and thermal extensions

Vadim says:

This patchset contains various improvements to hwmon and thermal code in
mlxsw. The most significant improvement is the ability to read modules'
temperature attributes (input, fault, critical and emergency thresholds)
as well as fans' fault indication. These new attributes will improve the
ability to monitor the system.

Patches #1-#4 add the necessary device registers and APIs to read
modules' temperature attributes and fans' fault indication.

Patches #5-#8 perform small improvements in hwmon and thermal code such
as using a more indicative name for cooling devices.

Patch #9 exposes fans' fault indication via hwmon.

Patch #10 exposes modules' temperature attributes via hwmon.

Patch #11 adds an hwmon label to modules' temperature sensor. This helps
to parse the output of utilities such as "sensors".

Patch #12 allows to bind an external cooling device ("mlxreg-fan") to
mlxsw thermal zone. This will allow the mlxsw thermal zone to change the
cooling level of cooling devices not programmed via switch registers.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 03b96742 97cd342a

drivers/net/ethernet/mellanox/mlxsw/Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

obj-$(CONFIG_MLXSW_CORE)	+= mlxsw_core.o

mlxsw_core-objs			:= core.o core_acl_flex_keys.o \

				   core_acl_flex_actions.o

				   core_acl_flex_actions.o core_env.o

mlxsw_core-$(CONFIG_MLXSW_CORE_HWMON) += core_hwmon.o

mlxsw_core-$(CONFIG_MLXSW_CORE_THERMAL) += core_thermal.o

obj-$(CONFIG_MLXSW_PCI)		+= mlxsw_pci.o

drivers/net/ethernet/mellanox/mlxsw/core.h

+1 −0
Original line number Diff line number Diff line
@@ -344,6 +344,7 @@ struct mlxsw_bus_info { 
	struct mlxsw_fw_rev fw_rev;

	u8 vsd[MLXSW_CMD_BOARDINFO_VSD_LEN];

	u8 psid[MLXSW_CMD_BOARDINFO_PSID_LEN];

	u8 low_frequency;

};



struct mlxsw_hwmon;

drivers/net/ethernet/mellanox/mlxsw/core_env.c

0 → 100644
+117 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0

/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */



#include <linux/kernel.h>

#include <linux/err.h>



#include "core.h"

#include "core_env.h"

#include "item.h"

#include "reg.h"



static int mlxsw_env_validate_cable_ident(struct mlxsw_core *core, int id,

					  bool *qsfp)

{

	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];

	char mcia_pl[MLXSW_REG_MCIA_LEN];

	u8 ident;

	int err;



	mlxsw_reg_mcia_pack(mcia_pl, id, 0, MLXSW_REG_MCIA_PAGE0_LO_OFF, 0, 1,

			    MLXSW_REG_MCIA_I2C_ADDR_LOW);

	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);

	if (err)

		return err;

	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);

	ident = eeprom_tmp[0];

	switch (ident) {

	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_SFP:

		*qsfp = false;

		break;

	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP: /* fall-through */

	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_PLUS: /* fall-through */

	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28: /* fall-through */

	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_DD:

		*qsfp = true;

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



int mlxsw_env_module_temp_thresholds_get(struct mlxsw_core *core, int module,

					 int off, int *temp)

{

	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];

	union {

		u8 buf[MLXSW_REG_MCIA_TH_ITEM_SIZE];

		u16 temp;

	} temp_thresh;

	char mcia_pl[MLXSW_REG_MCIA_LEN] = {0};

	char mtbr_pl[MLXSW_REG_MTBR_LEN] = {0};

	u16 module_temp;

	bool qsfp;

	int err;



	mlxsw_reg_mtbr_pack(mtbr_pl, MLXSW_REG_MTBR_BASE_MODULE_INDEX + module,

			    1);

	err = mlxsw_reg_query(core, MLXSW_REG(mtbr), mtbr_pl);

	if (err)

		return err;



	/* Don't read temperature thresholds for module with no valid info. */

	mlxsw_reg_mtbr_temp_unpack(mtbr_pl, 0, &module_temp, NULL);

	switch (module_temp) {

	case MLXSW_REG_MTBR_BAD_SENS_INFO: /* fall-through */

	case MLXSW_REG_MTBR_NO_CONN: /* fall-through */

	case MLXSW_REG_MTBR_NO_TEMP_SENS: /* fall-through */

	case MLXSW_REG_MTBR_INDEX_NA:

		*temp = 0;

		return 0;

	default:

		/* Do not consider thresholds for zero temperature. */

		if (!MLXSW_REG_MTMP_TEMP_TO_MC(module_temp)) {

			*temp = 0;

			return 0;

		}

		break;

	}



	/* Read Free Side Device Temperature Thresholds from page 03h

	 * (MSB at lower byte address).

	 * Bytes:

	 * 128-129 - Temp High Alarm (SFP_TEMP_HIGH_ALARM);

	 * 130-131 - Temp Low Alarm (SFP_TEMP_LOW_ALARM);

	 * 132-133 - Temp High Warning (SFP_TEMP_HIGH_WARN);

	 * 134-135 - Temp Low Warning (SFP_TEMP_LOW_WARN);

	 */



	/* Validate module identifier value. */

	err = mlxsw_env_validate_cable_ident(core, module, &qsfp);

	if (err)

		return err;



	if (qsfp)

		mlxsw_reg_mcia_pack(mcia_pl, module, 0,

				    MLXSW_REG_MCIA_TH_PAGE_NUM,

				    MLXSW_REG_MCIA_TH_PAGE_OFF + off,

				    MLXSW_REG_MCIA_TH_ITEM_SIZE,

				    MLXSW_REG_MCIA_I2C_ADDR_LOW);

	else

		mlxsw_reg_mcia_pack(mcia_pl, module, 0,

				    MLXSW_REG_MCIA_PAGE0_LO,

				    off, MLXSW_REG_MCIA_TH_ITEM_SIZE,

				    MLXSW_REG_MCIA_I2C_ADDR_HIGH);



	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);

	if (err)

		return err;



	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);

	memcpy(temp_thresh.buf, eeprom_tmp, MLXSW_REG_MCIA_TH_ITEM_SIZE);

	*temp = temp_thresh.temp * 1000;



	return 0;

}

drivers/net/ethernet/mellanox/mlxsw/core_env.h

0 → 100644
+10 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */

/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */



#ifndef _MLXSW_CORE_ENV_H

#define _MLXSW_CORE_ENV_H



int mlxsw_env_module_temp_thresholds_get(struct mlxsw_core *core, int module,

					 int off, int *temp);



#endif

drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c

+271 −4
Original line number Diff line number Diff line
@@ -7,8 +7,10 @@ 
#include <linux/sysfs.h>

#include <linux/hwmon.h>

#include <linux/err.h>

#include <linux/sfp.h>



#include "core.h"

#include "core_env.h"



#define MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT 127

#define MLXSW_HWMON_ATTR_COUNT (MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT * 4 + \
@@ -30,6 +32,7 @@ struct mlxsw_hwmon { 
	struct attribute *attrs[MLXSW_HWMON_ATTR_COUNT + 1];

	struct mlxsw_hwmon_attr hwmon_attrs[MLXSW_HWMON_ATTR_COUNT];

	unsigned int attrs_count;

	u8 sensor_count;

};



static ssize_t mlxsw_hwmon_temp_show(struct device *dev,
@@ -121,6 +124,27 @@ static ssize_t mlxsw_hwmon_fan_rpm_show(struct device *dev, 
	return sprintf(buf, "%u\n", mlxsw_reg_mfsm_rpm_get(mfsm_pl));

}



static ssize_t mlxsw_hwmon_fan_fault_show(struct device *dev,

					  struct device_attribute *attr,

					  char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char fore_pl[MLXSW_REG_FORE_LEN];

	bool fault;

	int err;



	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(fore), fore_pl);

	if (err) {

		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to query fan\n");

		return err;

	}

	mlxsw_reg_fore_unpack(fore_pl, mlwsw_hwmon_attr->type_index, &fault);



	return sprintf(buf, "%u\n", fault);

}



static ssize_t mlxsw_hwmon_pwm_show(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)
@@ -167,12 +191,160 @@ static ssize_t mlxsw_hwmon_pwm_store(struct device *dev, 
	return len;

}



static ssize_t mlxsw_hwmon_module_temp_show(struct device *dev,

					    struct device_attribute *attr,

					    char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char mtbr_pl[MLXSW_REG_MTBR_LEN] = {0};

	u16 temp;

	u8 module;

	int err;



	module = mlwsw_hwmon_attr->type_index - mlxsw_hwmon->sensor_count;

	mlxsw_reg_mtbr_pack(mtbr_pl, MLXSW_REG_MTBR_BASE_MODULE_INDEX + module,

			    1);

	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mtbr), mtbr_pl);

	if (err) {

		dev_err(dev, "Failed to query module temprature sensor\n");

		return err;

	}



	mlxsw_reg_mtbr_temp_unpack(mtbr_pl, 0, &temp, NULL);

	/* Update status and temperature cache. */

	switch (temp) {

	case MLXSW_REG_MTBR_NO_CONN: /* fall-through */

	case MLXSW_REG_MTBR_NO_TEMP_SENS: /* fall-through */

	case MLXSW_REG_MTBR_INDEX_NA:

		temp = 0;

		break;

	case MLXSW_REG_MTBR_BAD_SENS_INFO:

		/* Untrusted cable is connected. Reading temperature from its

		 * sensor is faulty.

		 */

		temp = 0;

		break;

	default:

		temp = MLXSW_REG_MTMP_TEMP_TO_MC(temp);

		break;

	}



	return sprintf(buf, "%u\n", temp);

}



static ssize_t mlxsw_hwmon_module_temp_fault_show(struct device *dev,

						  struct device_attribute *attr,

						  char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char mtbr_pl[MLXSW_REG_MTBR_LEN] = {0};

	u8 module, fault;

	u16 temp;

	int err;



	module = mlwsw_hwmon_attr->type_index - mlxsw_hwmon->sensor_count;

	mlxsw_reg_mtbr_pack(mtbr_pl, MLXSW_REG_MTBR_BASE_MODULE_INDEX + module,

			    1);

	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mtbr), mtbr_pl);

	if (err) {

		dev_err(dev, "Failed to query module temprature sensor\n");

		return err;

	}



	mlxsw_reg_mtbr_temp_unpack(mtbr_pl, 0, &temp, NULL);



	/* Update status and temperature cache. */

	switch (temp) {

	case MLXSW_REG_MTBR_BAD_SENS_INFO:

		/* Untrusted cable is connected. Reading temperature from its

		 * sensor is faulty.

		 */

		fault = 1;

		break;

	case MLXSW_REG_MTBR_NO_CONN: /* fall-through */

	case MLXSW_REG_MTBR_NO_TEMP_SENS: /* fall-through */

	case MLXSW_REG_MTBR_INDEX_NA:

	default:

		fault = 0;

		break;

	}



	return sprintf(buf, "%u\n", fault);

}



static ssize_t

mlxsw_hwmon_module_temp_critical_show(struct device *dev,

				      struct device_attribute *attr, char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	int temp;

	u8 module;

	int err;



	module = mlwsw_hwmon_attr->type_index - mlxsw_hwmon->sensor_count;

	err = mlxsw_env_module_temp_thresholds_get(mlxsw_hwmon->core, module,

						   SFP_TEMP_HIGH_WARN, &temp);

	if (err) {

		dev_err(dev, "Failed to query module temprature thresholds\n");

		return err;

	}



	return sprintf(buf, "%u\n", temp);

}



static ssize_t

mlxsw_hwmon_module_temp_emergency_show(struct device *dev,

				       struct device_attribute *attr,

				       char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	u8 module;

	int temp;

	int err;



	module = mlwsw_hwmon_attr->type_index - mlxsw_hwmon->sensor_count;

	err = mlxsw_env_module_temp_thresholds_get(mlxsw_hwmon->core, module,

						   SFP_TEMP_HIGH_ALARM, &temp);

	if (err) {

		dev_err(dev, "Failed to query module temprature thresholds\n");

		return err;

	}



	return sprintf(buf, "%u\n", temp);

}



static ssize_t

mlxsw_hwmon_module_temp_label_show(struct device *dev,

				   struct device_attribute *attr,

				   char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);



	return sprintf(buf, "front panel %03u\n",

		       mlwsw_hwmon_attr->type_index);

}



enum mlxsw_hwmon_attr_type {

	MLXSW_HWMON_ATTR_TYPE_TEMP,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MAX,

	MLXSW_HWMON_ATTR_TYPE_TEMP_RST,

	MLXSW_HWMON_ATTR_TYPE_FAN_RPM,

	MLXSW_HWMON_ATTR_TYPE_FAN_FAULT,

	MLXSW_HWMON_ATTR_TYPE_PWM,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_FAULT,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_CRIT,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_EMERG,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_LABEL,

};



static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon,
@@ -209,6 +381,12 @@ static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon, 
		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "fan%u_input", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_FAN_FAULT:

		mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_fan_fault_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "fan%u_fault", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_PWM:

		mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_pwm_show;

		mlxsw_hwmon_attr->dev_attr.store = mlxsw_hwmon_pwm_store;
@@ -216,6 +394,40 @@ static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon, 
		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "pwm%u", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE:

		mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_module_temp_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_input", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_FAULT:

		mlxsw_hwmon_attr->dev_attr.show =

					mlxsw_hwmon_module_temp_fault_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_fault", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_CRIT:

		mlxsw_hwmon_attr->dev_attr.show =

			mlxsw_hwmon_module_temp_critical_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_crit", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_EMERG:

		mlxsw_hwmon_attr->dev_attr.show =

			mlxsw_hwmon_module_temp_emergency_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_emergency", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_LABEL:

		mlxsw_hwmon_attr->dev_attr.show =

			mlxsw_hwmon_module_temp_label_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = 0444;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_label", num + 1);

		break;

	default:

		WARN_ON(1);

	}
@@ -233,7 +445,6 @@ static int mlxsw_hwmon_temp_init(struct mlxsw_hwmon *mlxsw_hwmon) 
{

	char mtcap_pl[MLXSW_REG_MTCAP_LEN] = {0};

	char mtmp_pl[MLXSW_REG_MTMP_LEN];

	u8 sensor_count;

	int i;

	int err;
@@ -242,8 +453,8 @@ static int mlxsw_hwmon_temp_init(struct mlxsw_hwmon *mlxsw_hwmon) 
		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to get number of temp sensors\n");

		return err;

	}

	sensor_count = mlxsw_reg_mtcap_sensor_count_get(mtcap_pl);

	for (i = 0; i < sensor_count; i++) {

	mlxsw_hwmon->sensor_count = mlxsw_reg_mtcap_sensor_count_get(mtcap_pl);

	for (i = 0; i < mlxsw_hwmon->sensor_count; i++) {

		mlxsw_reg_mtmp_pack(mtmp_pl, i, true, true);

		err = mlxsw_reg_write(mlxsw_hwmon->core,

				      MLXSW_REG(mtmp), mtmp_pl);
@@ -280,11 +491,15 @@ static int mlxsw_hwmon_fans_init(struct mlxsw_hwmon *mlxsw_hwmon) 
	mlxsw_reg_mfcr_unpack(mfcr_pl, &freq, &tacho_active, &pwm_active);

	num = 0;

	for (type_index = 0; type_index < MLXSW_MFCR_TACHOS_MAX; type_index++) {

		if (tacho_active & BIT(type_index))

		if (tacho_active & BIT(type_index)) {

			mlxsw_hwmon_attr_add(mlxsw_hwmon,

					     MLXSW_HWMON_ATTR_TYPE_FAN_RPM,

					     type_index, num);

			mlxsw_hwmon_attr_add(mlxsw_hwmon,

					     MLXSW_HWMON_ATTR_TYPE_FAN_FAULT,

					     type_index, num++);

		}

	}

	num = 0;

	for (type_index = 0; type_index < MLXSW_MFCR_PWMS_MAX; type_index++) {

		if (pwm_active & BIT(type_index))
@@ -295,6 +510,53 @@ static int mlxsw_hwmon_fans_init(struct mlxsw_hwmon *mlxsw_hwmon) 
	return 0;

}



static int mlxsw_hwmon_module_init(struct mlxsw_hwmon *mlxsw_hwmon)

{

	unsigned int module_count = mlxsw_core_max_ports(mlxsw_hwmon->core);

	char pmlp_pl[MLXSW_REG_PMLP_LEN] = {0};

	int i, index;

	u8 width;

	int err;



	/* Add extra attributes for module temperature. Sensor index is

	 * assigned to sensor_count value, while all indexed before

	 * sensor_count are already utilized by the sensors connected through

	 * mtmp register by mlxsw_hwmon_temp_init().

	 */

	index = mlxsw_hwmon->sensor_count;

	for (i = 1; i < module_count; i++) {

		mlxsw_reg_pmlp_pack(pmlp_pl, i);

		err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(pmlp),

				      pmlp_pl);

		if (err) {

			dev_err(mlxsw_hwmon->bus_info->dev, "Failed to read module index %d\n",

				i);

			return err;

		}

		width = mlxsw_reg_pmlp_width_get(pmlp_pl);

		if (!width)

			continue;

		mlxsw_hwmon_attr_add(mlxsw_hwmon,

				     MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE, index,

				     index);

		mlxsw_hwmon_attr_add(mlxsw_hwmon,

				     MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_FAULT,

				     index, index);

		mlxsw_hwmon_attr_add(mlxsw_hwmon,

				     MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_CRIT,

				     index, index);

		mlxsw_hwmon_attr_add(mlxsw_hwmon,

				     MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_EMERG,

				     index, index);

		mlxsw_hwmon_attr_add(mlxsw_hwmon,

				     MLXSW_HWMON_ATTR_TYPE_TEMP_MODULE_LABEL,

				     index, index);

		index++;

	}



	return 0;

}



int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,

		     const struct mlxsw_bus_info *mlxsw_bus_info,

		     struct mlxsw_hwmon **p_hwmon)
@@ -317,6 +579,10 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core, 
	if (err)

		goto err_fans_init;



	err = mlxsw_hwmon_module_init(mlxsw_hwmon);

	if (err)

		goto err_temp_module_init;



	mlxsw_hwmon->groups[0] = &mlxsw_hwmon->group;

	mlxsw_hwmon->group.attrs = mlxsw_hwmon->attrs;
@@ -333,6 +599,7 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core, 
	return 0;



err_hwmon_register:

err_temp_module_init:

err_fans_init:

err_temp_init:

	kfree(mlxsw_hwmon);

CRA Git | Maintained and supported by SUSTech CRA and CCSE