Commit 24770983 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'hwmon-for-v6.16-rc3' of... 

Merge tag 'hwmon-for-v6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging

Pull hwmon fixes from Guenter Roeck:

 - ltc4282: Avoid repeated register write operation

 - occ: Fix unaligned accesses, and rework attribute registration to
   reduce stack usage

 - ftsteutates: Fix TOCTOU race

* tag 'hwmon-for-v6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging:
  hwmon: (ltc4282) avoid repeated register write
  hwmon: (occ) fix unaligned accesses
  hwmon: (occ) Rework attribute registration for stack usage
  hwmon: (ftsteutates) Fix TOCTOU race in fts_read()
parents fb4d33ab c25892b7

drivers/hwmon/ftsteutates.c

+6 −3
Original line number Diff line number Diff line
@@ -423,13 +423,16 @@ static int fts_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 
		break;

	case hwmon_pwm:

		switch (attr) {

		case hwmon_pwm_auto_channels_temp:

			if (data->fan_source[channel] == FTS_FAN_SOURCE_INVALID)

		case hwmon_pwm_auto_channels_temp: {

			u8 fan_source = data->fan_source[channel];



			if (fan_source == FTS_FAN_SOURCE_INVALID || fan_source >= BITS_PER_LONG)

				*val = 0;

			else

				*val = BIT(data->fan_source[channel]);

				*val = BIT(fan_source);



			return 0;

		}

		default:

			break;

		}

drivers/hwmon/ltc4282.c

+0 −7
Original line number Diff line number Diff line
@@ -1511,13 +1511,6 @@ static int ltc4282_setup(struct ltc4282_state *st, struct device *dev) 
			return ret;

	}



	if (device_property_read_bool(dev, "adi,fault-log-enable")) {

		ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL,

				      LTC4282_FAULT_LOG_EN_MASK);

		if (ret)

			return ret;

	}



	if (device_property_read_bool(dev, "adi,fault-log-enable")) {

		ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL, LTC4282_FAULT_LOG_EN_MASK);

		if (ret)

drivers/hwmon/occ/common.c

+98 −142
Original line number Diff line number Diff line
@@ -459,12 +459,10 @@ static ssize_t occ_show_power_1(struct device *dev, 
	return sysfs_emit(buf, "%llu\n", val);

}



static u64 occ_get_powr_avg(u64 *accum, u32 *samples)

static u64 occ_get_powr_avg(u64 accum, u32 samples)

{

	u64 divisor = get_unaligned_be32(samples);



	return (divisor == 0) ? 0 :

		div64_u64(get_unaligned_be64(accum) * 1000000ULL, divisor);

	return (samples == 0) ? 0 :

		mul_u64_u32_div(accum, 1000000UL, samples);

}



static ssize_t occ_show_power_2(struct device *dev,
@@ -489,8 +487,8 @@ static ssize_t occ_show_power_2(struct device *dev, 
				  get_unaligned_be32(&power->sensor_id),

				  power->function_id, power->apss_channel);

	case 1:

		val = occ_get_powr_avg(&power->accumulator,

				       &power->update_tag);

		val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator),

				       get_unaligned_be32(&power->update_tag));

		break;

	case 2:

		val = (u64)get_unaligned_be32(&power->update_tag) *
@@ -527,8 +525,8 @@ static ssize_t occ_show_power_a0(struct device *dev, 
		return sysfs_emit(buf, "%u_system\n",

				  get_unaligned_be32(&power->sensor_id));

	case 1:

		val = occ_get_powr_avg(&power->system.accumulator,

				       &power->system.update_tag);

		val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator),

				       get_unaligned_be32(&power->system.update_tag));

		break;

	case 2:

		val = (u64)get_unaligned_be32(&power->system.update_tag) *
@@ -541,8 +539,8 @@ static ssize_t occ_show_power_a0(struct device *dev, 
		return sysfs_emit(buf, "%u_proc\n",

				  get_unaligned_be32(&power->sensor_id));

	case 5:

		val = occ_get_powr_avg(&power->proc.accumulator,

				       &power->proc.update_tag);

		val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator),

				       get_unaligned_be32(&power->proc.update_tag));

		break;

	case 6:

		val = (u64)get_unaligned_be32(&power->proc.update_tag) *
@@ -555,8 +553,8 @@ static ssize_t occ_show_power_a0(struct device *dev, 
		return sysfs_emit(buf, "%u_vdd\n",

				  get_unaligned_be32(&power->sensor_id));

	case 9:

		val = occ_get_powr_avg(&power->vdd.accumulator,

				       &power->vdd.update_tag);

		val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator),

				       get_unaligned_be32(&power->vdd.update_tag));

		break;

	case 10:

		val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
@@ -569,8 +567,8 @@ static ssize_t occ_show_power_a0(struct device *dev, 
		return sysfs_emit(buf, "%u_vdn\n",

				  get_unaligned_be32(&power->sensor_id));

	case 13:

		val = occ_get_powr_avg(&power->vdn.accumulator,

				       &power->vdn.update_tag);

		val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator),

				       get_unaligned_be32(&power->vdn.update_tag));

		break;

	case 14:

		val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
@@ -747,28 +745,29 @@ static ssize_t occ_show_extended(struct device *dev, 
}



/*

 * Some helper macros to make it easier to define an occ_attribute. Since these

 * are dynamically allocated, we shouldn't use the existing kernel macros which

 * A helper to make it easier to define an occ_attribute. Since these

 * are dynamically allocated, we cannot use the existing kernel macros which

 * stringify the name argument.

 */

#define ATTR_OCC(_name, _mode, _show, _store) {				\

	.attr	= {							\

		.name = _name,						\

		.mode = VERIFY_OCTAL_PERMISSIONS(_mode),		\

	},								\

	.show	= _show,						\

	.store	= _store,						\

}

static void occ_init_attribute(struct occ_attribute *attr, int mode,

	ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf),

	ssize_t (*store)(struct device *dev, struct device_attribute *attr,

				   const char *buf, size_t count),

	int nr, int index, const char *fmt, ...)

{

	va_list args;



#define SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index) {	\

	.dev_attr	= ATTR_OCC(_name, _mode, _show, _store),	\

	.index		= _index,					\

	.nr		= _nr,						\

}

	va_start(args, fmt);

	vsnprintf(attr->name, sizeof(attr->name), fmt, args);

	va_end(args);



#define OCC_INIT_ATTR(_name, _mode, _show, _store, _nr, _index)		\

	((struct sensor_device_attribute_2)				\

		SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index))

	attr->sensor.dev_attr.attr.name = attr->name;

	attr->sensor.dev_attr.attr.mode = mode;

	attr->sensor.dev_attr.show = show;

	attr->sensor.dev_attr.store = store;

	attr->sensor.index = index;

	attr->sensor.nr = nr;

}



/*

 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
@@ -855,14 +854,15 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
		sensors->extended.num_sensors = 0;

	}



	occ->attrs = devm_kzalloc(dev, sizeof(*occ->attrs) * num_attrs,

	occ->attrs = devm_kcalloc(dev, num_attrs, sizeof(*occ->attrs),

				  GFP_KERNEL);

	if (!occ->attrs)

		return -ENOMEM;



	/* null-terminated list */

	occ->group.attrs = devm_kzalloc(dev, sizeof(*occ->group.attrs) *

					num_attrs + 1, GFP_KERNEL);

	occ->group.attrs = devm_kcalloc(dev, num_attrs + 1,

					sizeof(*occ->group.attrs),

					GFP_KERNEL);

	if (!occ->group.attrs)

		return -ENOMEM;
@@ -872,43 +872,33 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
		s = i + 1;

		temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;



		snprintf(attr->name, sizeof(attr->name), "temp%d_label", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,

					     0, i);

		occ_init_attribute(attr, 0444, show_temp, NULL,

				   0, i, "temp%d_label", s);

		attr++;



		if (sensors->temp.version == 2 &&

		    temp->fru_type == OCC_FRU_TYPE_VRM) {

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

				 "temp%d_alarm", s);

			occ_init_attribute(attr, 0444, show_temp, NULL,

					   1, i, "temp%d_alarm", s);

		} else {

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

				 "temp%d_input", s);

			occ_init_attribute(attr, 0444, show_temp, NULL,

					   1, i, "temp%d_input", s);

		}



		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,

					     1, i);

		attr++;



		if (sensors->temp.version > 1) {

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

				 "temp%d_fru_type", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_temp, NULL, 2, i);

			occ_init_attribute(attr, 0444, show_temp, NULL,

					   2, i, "temp%d_fru_type", s);

			attr++;



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

				 "temp%d_fault", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_temp, NULL, 3, i);

			occ_init_attribute(attr, 0444, show_temp, NULL,

					   3, i, "temp%d_fault", s);

			attr++;



			if (sensors->temp.version == 0x10) {

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

					 "temp%d_max", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_temp, NULL,

							     4, i);

				occ_init_attribute(attr, 0444, show_temp, NULL,

						   4, i, "temp%d_max", s);

				attr++;

			}

		}
@@ -917,14 +907,12 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
	for (i = 0; i < sensors->freq.num_sensors; ++i) {

		s = i + 1;



		snprintf(attr->name, sizeof(attr->name), "freq%d_label", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,

					     0, i);

		occ_init_attribute(attr, 0444, show_freq, NULL,

				   0, i, "freq%d_label", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "freq%d_input", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,

					     1, i);

		occ_init_attribute(attr, 0444, show_freq, NULL,

				   1, i, "freq%d_input", s);

		attr++;

	}
@@ -940,32 +928,24 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
			s = (i * 4) + 1;



			for (j = 0; j < 4; ++j) {

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

				occ_init_attribute(attr, 0444, show_power,

						   NULL, nr++, i,

						   "power%d_label", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_power, NULL,

							     nr++, i);

				attr++;



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

				occ_init_attribute(attr, 0444, show_power,

						   NULL, nr++, i,

						   "power%d_average", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_power, NULL,

							     nr++, i);

				attr++;



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

				occ_init_attribute(attr, 0444, show_power,

						   NULL, nr++, i,

						   "power%d_average_interval", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_power, NULL,

							     nr++, i);

				attr++;



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

				occ_init_attribute(attr, 0444, show_power,

						   NULL, nr++, i,

						   "power%d_input", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_power, NULL,

							     nr++, i);

				attr++;



				s++;
@@ -977,28 +957,20 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
		for (i = 0; i < sensors->power.num_sensors; ++i) {

			s = i + 1;



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

				 "power%d_label", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_power, NULL, 0, i);

			occ_init_attribute(attr, 0444, show_power, NULL,

					   0, i, "power%d_label", s);

			attr++;



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

				 "power%d_average", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_power, NULL, 1, i);

			occ_init_attribute(attr, 0444, show_power, NULL,

					   1, i, "power%d_average", s);

			attr++;



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

				 "power%d_average_interval", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_power, NULL, 2, i);

			occ_init_attribute(attr, 0444, show_power, NULL,

					   2, i, "power%d_average_interval", s);

			attr++;



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

				 "power%d_input", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_power, NULL, 3, i);

			occ_init_attribute(attr, 0444, show_power, NULL,

					   3, i, "power%d_input", s);

			attr++;

		}
@@ -1006,56 +978,43 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
	}



	if (sensors->caps.num_sensors >= 1) {

		snprintf(attr->name, sizeof(attr->name), "power%d_label", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     0, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   0, 0, "power%d_label", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "power%d_cap", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     1, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   1, 0, "power%d_cap", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "power%d_input", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     2, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   2, 0, "power%d_input", s);

		attr++;



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

			 "power%d_cap_not_redundant", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     3, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   3, 0, "power%d_cap_not_redundant", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "power%d_cap_max", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     4, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   4, 0, "power%d_cap_max", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "power%d_cap_min", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,

					     5, 0);

		occ_init_attribute(attr, 0444, show_caps, NULL,

				   5, 0, "power%d_cap_min", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "power%d_cap_user",

			 s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0644, show_caps,

					     occ_store_caps_user, 6, 0);

		occ_init_attribute(attr, 0644, show_caps, occ_store_caps_user,

				   6, 0, "power%d_cap_user", s);

		attr++;



		if (sensors->caps.version > 1) {

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

				 "power%d_cap_user_source", s);

			attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

						     show_caps, NULL, 7, 0);

			occ_init_attribute(attr, 0444, show_caps, NULL,

					   7, 0, "power%d_cap_user_source", s);

			attr++;



			if (sensors->caps.version > 2) {

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

				occ_init_attribute(attr, 0444, show_caps, NULL,

						   8, 0,

						   "power%d_cap_min_soft", s);

				attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

							     show_caps, NULL,

							     8, 0);

				attr++;

			}

		}
@@ -1064,19 +1023,16 @@ static int occ_setup_sensor_attrs(struct occ *occ) 
	for (i = 0; i < sensors->extended.num_sensors; ++i) {

		s = i + 1;



		snprintf(attr->name, sizeof(attr->name), "extn%d_label", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

					     occ_show_extended, NULL, 0, i);

		occ_init_attribute(attr, 0444, occ_show_extended, NULL,

				   0, i, "extn%d_label", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "extn%d_flags", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

					     occ_show_extended, NULL, 1, i);

		occ_init_attribute(attr, 0444, occ_show_extended, NULL,

				   1, i, "extn%d_flags", s);

		attr++;



		snprintf(attr->name, sizeof(attr->name), "extn%d_input", s);

		attr->sensor = OCC_INIT_ATTR(attr->name, 0444,

					     occ_show_extended, NULL, 2, i);

		occ_init_attribute(attr, 0444, occ_show_extended, NULL,

				   2, i, "extn%d_input", s);

		attr++;

	}