277 lines
8.1 KiB
C
277 lines
8.1 KiB
C
|
// SPDX-License-Identifier: GPL-2.0
|
||
|
|
/*
|
||
|
|
* helpers to map values in a linear range to range index
|
||
|
|
*
|
||
|
|
* Original idea borrowed from regulator framework
|
||
|
|
*
|
||
|
|
* It might be useful if we could support also inversely proportional ranges?
|
||
|
|
* Copyright 2020 ROHM Semiconductors
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/errno.h>
|
||
|
|
#include <linux/export.h>
|
||
|
|
#include <linux/kernel.h>
|
||
|
|
#include <linux/linear_range.h>
|
||
|
|
#include <linux/module.h>
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_values_in_range - return the amount of values in a range
|
||
|
|
* @r: pointer to linear range where values are counted
|
||
|
|
*
|
||
|
|
* Compute the amount of values in range pointed by @r. Note, values can
|
||
|
|
* be all equal - range with selectors 0,...,2 with step 0 still contains
|
||
|
|
* 3 values even though they are all equal.
|
||
|
|
*
|
||
|
|
* Return: the amount of values in range pointed by @r
|
||
|
|
*/
|
||
|
|
unsigned int linear_range_values_in_range(const struct linear_range *r)
|
||
|
|
{
|
||
|
|
if (!r)
|
||
|
|
return 0;
|
||
|
|
return r->max_sel - r->min_sel + 1;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_values_in_range);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_values_in_range_array - return the amount of values in ranges
|
||
|
|
* @r: pointer to array of linear ranges where values are counted
|
||
|
|
* @ranges: amount of ranges we include in computation.
|
||
|
|
*
|
||
|
|
* Compute the amount of values in ranges pointed by @r. Note, values can
|
||
|
|
* be all equal - range with selectors 0,...,2 with step 0 still contains
|
||
|
|
* 3 values even though they are all equal.
|
||
|
|
*
|
||
|
|
* Return: the amount of values in first @ranges ranges pointed by @r
|
||
|
|
*/
|
||
|
|
unsigned int linear_range_values_in_range_array(const struct linear_range *r,
|
||
|
|
int ranges)
|
||
|
|
{
|
||
|
|
int i, values_in_range = 0;
|
||
|
|
|
||
|
|
for (i = 0; i < ranges; i++) {
|
||
|
|
int values;
|
||
|
|
|
||
|
|
values = linear_range_values_in_range(&r[i]);
|
||
|
|
if (!values)
|
||
|
|
return values;
|
||
|
|
|
||
|
|
values_in_range += values;
|
||
|
|
}
|
||
|
|
return values_in_range;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_values_in_range_array);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_max_value - return the largest value in a range
|
||
|
|
* @r: pointer to linear range where value is looked from
|
||
|
|
*
|
||
|
|
* Return: the largest value in the given range
|
||
|
|
*/
|
||
|
|
unsigned int linear_range_get_max_value(const struct linear_range *r)
|
||
|
|
{
|
||
|
|
return r->min + (r->max_sel - r->min_sel) * r->step;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_max_value);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_value - fetch a value from given range
|
||
|
|
* @r: pointer to linear range where value is looked from
|
||
|
|
* @selector: selector for which the value is searched
|
||
|
|
* @val: address where found value is updated
|
||
|
|
*
|
||
|
|
* Search given ranges for value which matches given selector.
|
||
|
|
*
|
||
|
|
* Return: 0 on success, -EINVAL given selector is not found from any of the
|
||
|
|
* ranges.
|
||
|
|
*/
|
||
|
|
int linear_range_get_value(const struct linear_range *r, unsigned int selector,
|
||
|
|
unsigned int *val)
|
||
|
|
{
|
||
|
|
if (r->min_sel > selector || r->max_sel < selector)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
*val = r->min + (selector - r->min_sel) * r->step;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_value);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_value_array - fetch a value from array of ranges
|
||
|
|
* @r: pointer to array of linear ranges where value is looked from
|
||
|
|
* @ranges: amount of ranges in an array
|
||
|
|
* @selector: selector for which the value is searched
|
||
|
|
* @val: address where found value is updated
|
||
|
|
*
|
||
|
|
* Search through an array of ranges for value which matches given selector.
|
||
|
|
*
|
||
|
|
* Return: 0 on success, -EINVAL given selector is not found from any of the
|
||
|
|
* ranges.
|
||
|
|
*/
|
||
|
|
int linear_range_get_value_array(const struct linear_range *r, int ranges,
|
||
|
|
unsigned int selector, unsigned int *val)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = 0; i < ranges; i++)
|
||
|
|
if (r[i].min_sel <= selector && r[i].max_sel >= selector)
|
||
|
|
return linear_range_get_value(&r[i], selector, val);
|
||
|
|
|
||
|
|
return -EINVAL;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_value_array);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_selector_low - return linear range selector for value
|
||
|
|
* @r: pointer to linear range where selector is looked from
|
||
|
|
* @val: value for which the selector is searched
|
||
|
|
* @selector: address where found selector value is updated
|
||
|
|
* @found: flag to indicate that given value was in the range
|
||
|
|
*
|
||
|
|
* Return selector for which range value is closest match for given
|
||
|
|
* input value. Value is matching if it is equal or smaller than given
|
||
|
|
* value. If given value is in the range, then @found is set true.
|
||
|
|
*
|
||
|
|
* Return: 0 on success, -EINVAL if range is invalid or does not contain
|
||
|
|
* value smaller or equal to given value
|
||
|
|
*/
|
||
|
|
int linear_range_get_selector_low(const struct linear_range *r,
|
||
|
|
unsigned int val, unsigned int *selector,
|
||
|
|
bool *found)
|
||
|
|
{
|
||
|
|
*found = false;
|
||
|
|
|
||
|
|
if (r->min > val)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
if (linear_range_get_max_value(r) < val) {
|
||
|
|
*selector = r->max_sel;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
*found = true;
|
||
|
|
|
||
|
|
if (r->step == 0)
|
||
|
|
*selector = r->min_sel;
|
||
|
|
else
|
||
|
|
*selector = (val - r->min) / r->step + r->min_sel;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_selector_low);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_selector_low_array - return linear range selector for value
|
||
|
|
* @r: pointer to array of linear ranges where selector is looked from
|
||
|
|
* @ranges: amount of ranges to scan from array
|
||
|
|
* @val: value for which the selector is searched
|
||
|
|
* @selector: address where found selector value is updated
|
||
|
|
* @found: flag to indicate that given value was in the range
|
||
|
|
*
|
||
|
|
* Scan array of ranges for selector for which range value matches given
|
||
|
|
* input value. Value is matching if it is equal or smaller than given
|
||
|
|
* value. If given value is found to be in a range scanning is stopped and
|
||
|
|
* @found is set true. If a range with values smaller than given value is found
|
||
|
|
* but the range max is being smaller than given value, then the range's
|
||
|
|
* biggest selector is updated to @selector but scanning ranges is continued
|
||
|
|
* and @found is set to false.
|
||
|
|
*
|
||
|
|
* Return: 0 on success, -EINVAL if range array is invalid or does not contain
|
||
|
|
* range with a value smaller or equal to given value
|
||
|
|
*/
|
||
|
|
int linear_range_get_selector_low_array(const struct linear_range *r,
|
||
|
|
int ranges, unsigned int val,
|
||
|
|
unsigned int *selector, bool *found)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
int ret = -EINVAL;
|
||
|
|
|
||
|
|
for (i = 0; i < ranges; i++) {
|
||
|
|
int tmpret;
|
||
|
|
|
||
|
|
tmpret = linear_range_get_selector_low(&r[i], val, selector,
|
||
|
|
found);
|
||
|
|
if (!tmpret)
|
||
|
|
ret = 0;
|
||
|
|
|
||
|
|
if (*found)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_selector_low_array);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_selector_high - return linear range selector for value
|
||
|
|
* @r: pointer to linear range where selector is looked from
|
||
|
|
* @val: value for which the selector is searched
|
||
|
|
* @selector: address where found selector value is updated
|
||
|
|
* @found: flag to indicate that given value was in the range
|
||
|
|
*
|
||
|
|
* Return selector for which range value is closest match for given
|
||
|
|
* input value. Value is matching if it is equal or higher than given
|
||
|
|
* value. If given value is in the range, then @found is set true.
|
||
|
|
*
|
||
|
|
* Return: 0 on success, -EINVAL if range is invalid or does not contain
|
||
|
|
* value greater or equal to given value
|
||
|
|
*/
|
||
|
|
int linear_range_get_selector_high(const struct linear_range *r,
|
||
|
|
unsigned int val, unsigned int *selector,
|
||
|
|
bool *found)
|
||
|
|
{
|
||
|
|
*found = false;
|
||
|
|
|
||
|
|
if (linear_range_get_max_value(r) < val)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
if (r->min > val) {
|
||
|
|
*selector = r->min_sel;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
*found = true;
|
||
|
|
|
||
|
|
if (r->step == 0)
|
||
|
|
*selector = r->max_sel;
|
||
|
|
else
|
||
|
|
*selector = DIV_ROUND_UP(val - r->min, r->step) + r->min_sel;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_selector_high);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* linear_range_get_selector_within - return linear range selector for value
|
||
|
|
* @r: pointer to linear range where selector is looked from
|
||
|
|
* @val: value for which the selector is searched
|
||
|
|
* @selector: address where found selector value is updated
|
||
|
|
*
|
||
|
|
* Return selector for which range value is closest match for given
|
||
|
|
* input value. Value is matching if it is equal or lower than given
|
||
|
|
* value. But return maximum selector if given value is higher than
|
||
|
|
* maximum value.
|
||
|
|
*/
|
||
|
|
void linear_range_get_selector_within(const struct linear_range *r,
|
||
|
|
unsigned int val, unsigned int *selector)
|
||
|
|
{
|
||
|
|
if (r->min > val) {
|
||
|
|
*selector = r->min_sel;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (linear_range_get_max_value(r) < val) {
|
||
|
|
*selector = r->max_sel;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (r->step == 0)
|
||
|
|
*selector = r->min_sel;
|
||
|
|
else
|
||
|
|
*selector = (val - r->min) / r->step + r->min_sel;
|
||
|
|
}
|
||
|
|
EXPORT_SYMBOL_GPL(linear_range_get_selector_within);
|
||
|
|
|
||
|
|
MODULE_DESCRIPTION("linear-ranges helper");
|
||
|
|
MODULE_LICENSE("GPL");
|