| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <2a503edb-fe9f-4d61-92c0-c1083a028e19@baylibre.com>
Date: Thu, 25 Sep 2025 16:10:14 -0500
From: David Lechner <dlechner@...libre.com>
To: Romain Gantois <romain.gantois@...tlin.com>,
Liam Girdwood <lgirdwood@...il.com>, Mark Brown <broonie@...nel.org>,
Rob Herring <robh@...nel.org>, Krzysztof Kozlowski <krzk+dt@...nel.org>,
Conor Dooley <conor+dt@...nel.org>, Jonathan Cameron <jic23@...nel.org>,
Nuno Sá <nuno.sa@...log.com>,
Andy Shevchenko <andy@...nel.org>
Cc: Hans de Goede <hansg@...nel.org>,
Thomas Petazzoni <thomas.petazzoni@...tlin.com>,
linux-kernel@...r.kernel.org, devicetree@...r.kernel.org,
linux-iio@...r.kernel.org
Subject: Re: [PATCH v2 2/5] iio: add processed write API
On 9/25/25 7:37 AM, Romain Gantois wrote:
> Add a function to allow IIO consumers to write a processed value to a
> channel.
>
> Signed-off-by: Romain Gantois <romain.gantois@...tlin.com>
> ---
> drivers/iio/inkern.c | 120 +++++++++++++++++++++++++++++++++++++++++++
> include/linux/iio/consumer.h | 36 +++++++++++++
> 2 files changed, 156 insertions(+)
>
> diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
> index 2a1ecef2b82007f5ee8e8d0f8b35846bc4d2f94a..a6ec724b7c1fb197e6261c1162f8315deda20fd7 100644
> --- a/drivers/iio/inkern.c
> +++ b/drivers/iio/inkern.c
> @@ -631,6 +631,57 @@ int iio_multiply_value(int *result, s64 multiplier,
> }
> EXPORT_SYMBOL_GPL(iio_multiply_value);
>
> +int iio_divide_by_value(int *result, s64 numerator,
> + unsigned int type, int val, int val2)
> +{
> + s64 tmp_num, tmp_den;
> +
> + switch (type) {
> + case IIO_VAL_INT:
> + tmp_num = numerator;
> + tmp_den = val;
> + break;
> + case IIO_VAL_INT_PLUS_MICRO:
> + case IIO_VAL_INT_PLUS_NANO:
> + switch (type) {
> + case IIO_VAL_INT_PLUS_MICRO:
> + tmp_num = MICRO;
> + tmp_den = MICRO;
> + break;
> +
> + case IIO_VAL_INT_PLUS_NANO:
> + tmp_num = NANO;
> + tmp_den = NANO;
> + break;
> + }
> +
> + tmp_num *= (s64)numerator;
> + tmp_den = (s64)abs(val) * tmp_den + (s64)abs(val2);
> +
> + if (val < 0 || val2 < 0)
> + tmp_num *= -1;
> +
> + break;
> + case IIO_VAL_FRACTIONAL:
> + tmp_num = (s64)numerator * (s64)val2;
> + tmp_den = val;
> + break;
> + case IIO_VAL_FRACTIONAL_LOG2:
> + tmp_num = (s64)numerator << val2;
> + tmp_den = val;
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + if (!tmp_den)
> + return -ERANGE;
> +
> + *result = div64_s64(tmp_num, tmp_den);
> +
> + return IIO_VAL_INT;
> +}
> +
> static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
> int raw, int *processed,
> unsigned int scale)
> @@ -699,6 +750,53 @@ int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
> }
> EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
>
> +static int iio_convert_processed_to_raw_unlocked(struct iio_channel *chan,
> + int processed, int *raw,
> + unsigned int scale)
> +{
> + int scale_type, scale_val, scale_val2;
> + int offset_type, offset_val, offset_val2;
> + int ret;
> +
> + scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
> + IIO_CHAN_INFO_SCALE);
> + if (scale_type >= 0) {
> + ret = iio_divide_by_value(raw, processed, scale_type, scale_val, scale_val2);
> + if (ret < 0)
> + return ret;
> + } else {
> + *raw = processed;
> + }
> +
> + if (!scale)
> + return -ERANGE;
> +
> + *raw = div_s64(*raw, scale);
> +
> + offset_type = iio_channel_read(chan, &offset_val, &offset_val2,
> + IIO_CHAN_INFO_OFFSET);
> + if (offset_type >= 0) {
> + switch (offset_type) {
> + case IIO_VAL_INT:
> + case IIO_VAL_INT_PLUS_MICRO:
> + case IIO_VAL_INT_PLUS_NANO:
> + break;
> + case IIO_VAL_FRACTIONAL:
> + offset_val /= offset_val2;
> + break;
> + case IIO_VAL_FRACTIONAL_LOG2:
> + offset_val >>= offset_val2;
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + *raw -= offset_val;
> + }
There are some rounding biases in this function, but I'm not sure if
it is worth trying to make a perfectly fair function.
> +
> + return 0;
> +}
> +
> int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
> enum iio_chan_info_enum attribute)
> {
> @@ -1035,3 +1133,25 @@ ssize_t iio_read_channel_label(struct iio_channel *chan, char *buf)
> return do_iio_read_channel_label(chan->indio_dev, chan->channel, buf);
> }
> EXPORT_SYMBOL_GPL(iio_read_channel_label);
> +
> +int iio_write_channel_processed_scale(struct iio_channel *chan, int val,
> + unsigned int scale)
> +{
> + struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
> + int ret, processed;
> +
> + scoped_guard(mutex, &iio_dev_opaque->info_exist_lock) {
Can just use regular guard(mutex)() here and save some indent.
> + if (!chan->indio_dev->info)
> + return -ENODEV;
> +
> + ret = iio_convert_processed_to_raw_unlocked(chan, val, &processed, scale);
> + if (ret)
> + return ret;
> +
> + ret = iio_channel_write(chan, processed, 0, IIO_CHAN_INFO_RAW);
And this can return directly.
> + }
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(iio_write_channel_processed_scale);
> +
> diff --git a/include/linux/iio/consumer.h b/include/linux/iio/consumer.h
> index c8c6261c81f934480e16854412e269207be60adc..dc84b8b4c61911d1a58427f1a9c798cae3954ac1 100644
> --- a/include/linux/iio/consumer.h
> +++ b/include/linux/iio/consumer.h
> @@ -399,6 +399,24 @@ int iio_read_channel_scale(struct iio_channel *chan, int *val,
> int iio_multiply_value(int *result, s64 multiplier,
> unsigned int type, int val, int val2);
>
> +/**
> + * iio_divide_by_value() - Divide by an IIO value
> + * @result: Destination pointer for the division result
> + * @numerator: Numerator.
> + * @type: One of the IIO_VAL_* constants. This decides how the @val
> + * and @val2 parameters are interpreted.
> + * @val: Denominator.
> + * @val2: Denominator. @val2 use depends on type.
> + *
> + * Divide an s64 number by an IIO value, storing the result as
> + * IIO_VAL_INT. This is typically used for scaling.
> + *
> + * Returns:
> + * IIO_VAL_INT on success or a negative error-number on failure.
> + */
> +int iio_divide_by_value(int *result, s64 numerator,
> + unsigned int type, int val, int val2);
> +
> /**
> * iio_convert_raw_to_processed() - Converts a raw value to a processed value
> * @chan: The channel being queried
> @@ -469,4 +487,22 @@ ssize_t iio_write_channel_ext_info(struct iio_channel *chan, const char *attr,
> */
> ssize_t iio_read_channel_label(struct iio_channel *chan, char *buf);
>
> +/**
> + * iio_write_channel_processed_scale() - scale and write processed value to a given channel
> + * @chan: The channel being queried.
> + * @val: Value to write.
> + * @scale: Scale factor to apply during the conversion
This could be more explicit about what sort of scaling this is.
The function divides by this factor rather than multiplies by it.
> + *
> + * This function writes a processed value to a channel. A processed value means
> + * that this value will have the correct unit and not some device internal
> + * representation. If the device does not support writing a processed value, the
> + * function will query the channel's scale and offset and write an appropriately
> + * transformed raw value.
> + *
Could be helpful even if obvious to most people...
Context: May sleep.
> + * Return: an error code or 0.
> + *
> + */
> +int iio_write_channel_processed_scale(struct iio_channel *chan, int val,
> + unsigned int scale);
> +
> #endif
>
Powered by blists - more mailing lists