projects/linux·blob uaccess-cleanups · refs

312 lines · 9.4 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * helpers to map values in a linear range to range index
4 *
5 * Original idea borrowed from regulator framework
6 *
7 * It might be useful if we could support also inversely proportional ranges?
8 * Copyright 2020 ROHM Semiconductors
9 */
10
11#include <linux/errno.h>
12#include <linux/export.h>
13#include <linux/kernel.h>
14#include <linux/linear_range.h>
15#include <linux/module.h>
16
17/**
18 * linear_range_values_in_range - return the amount of values in a range
19 * @r: pointer to linear range where values are counted
20 *
21 * Compute the amount of values in range pointed by @r. Note, values can
22 * be all equal - range with selectors 0,...,2 with step 0 still contains
23 * 3 values even though they are all equal.
24 *
25 * Return: the amount of values in range pointed by @r
26 */
27unsigned int linear_range_values_in_range(const struct linear_range *r)
28{
29 if (!r)
30 return 0;
31 return r->max_sel - r->min_sel + 1;
32}
33EXPORT_SYMBOL_GPL(linear_range_values_in_range);
34
35/**
36 * linear_range_values_in_range_array - return the amount of values in ranges
37 * @r: pointer to array of linear ranges where values are counted
38 * @ranges: amount of ranges we include in computation.
39 *
40 * Compute the amount of values in ranges pointed by @r. Note, values can
41 * be all equal - range with selectors 0,...,2 with step 0 still contains
42 * 3 values even though they are all equal.
43 *
44 * Return: the amount of values in first @ranges ranges pointed by @r
45 */
46unsigned int linear_range_values_in_range_array(const struct linear_range *r,
47 int ranges)
48{
49 int i, values_in_range = 0;
50
51 for (i = 0; i < ranges; i++) {
52 int values;
53
54 values = linear_range_values_in_range(&r[i]);
55 if (!values)
56 return values;
57
58 values_in_range += values;
59 }
60 return values_in_range;
61}
62EXPORT_SYMBOL_GPL(linear_range_values_in_range_array);
63
64/**
65 * linear_range_get_max_value - return the largest value in a range
66 * @r: pointer to linear range where value is looked from
67 *
68 * Return: the largest value in the given range
69 */
70unsigned int linear_range_get_max_value(const struct linear_range *r)
71{
72 return r->min + (r->max_sel - r->min_sel) * r->step;
73}
74EXPORT_SYMBOL_GPL(linear_range_get_max_value);
75
76/**
77 * linear_range_get_value - fetch a value from given range
78 * @r: pointer to linear range where value is looked from
79 * @selector: selector for which the value is searched
80 * @val: address where found value is updated
81 *
82 * Search given ranges for value which matches given selector.
83 *
84 * Return: 0 on success, -EINVAL given selector is not found from any of the
85 * ranges.
86 */
87int linear_range_get_value(const struct linear_range *r, unsigned int selector,
88 unsigned int *val)
89{
90 if (r->min_sel > selector || r->max_sel < selector)
91 return -EINVAL;
92
93 *val = r->min + (selector - r->min_sel) * r->step;
94
95 return 0;
96}
97EXPORT_SYMBOL_GPL(linear_range_get_value);
98
99/**
100 * linear_range_get_value_array - fetch a value from array of ranges
101 * @r: pointer to array of linear ranges where value is looked from
102 * @ranges: amount of ranges in an array
103 * @selector: selector for which the value is searched
104 * @val: address where found value is updated
105 *
106 * Search through an array of ranges for value which matches given selector.
107 *
108 * Return: 0 on success, -EINVAL given selector is not found from any of the
109 * ranges.
110 */
111int linear_range_get_value_array(const struct linear_range *r, int ranges,
112 unsigned int selector, unsigned int *val)
113{
114 int i;
115
116 for (i = 0; i < ranges; i++)
117 if (r[i].min_sel <= selector && r[i].max_sel >= selector)
118 return linear_range_get_value(&r[i], selector, val);
119
120 return -EINVAL;
121}
122EXPORT_SYMBOL_GPL(linear_range_get_value_array);
123
124/**
125 * linear_range_get_selector_low - return linear range selector for value
126 * @r: pointer to linear range where selector is looked from
127 * @val: value for which the selector is searched
128 * @selector: address where found selector value is updated
129 * @found: flag to indicate that given value was in the range
130 *
131 * Return selector for which range value is closest match for given
132 * input value. Value is matching if it is equal or smaller than given
133 * value. If given value is in the range, then @found is set true.
134 *
135 * Return: 0 on success, -EINVAL if range is invalid or does not contain
136 * value smaller or equal to given value
137 */
138int linear_range_get_selector_low(const struct linear_range *r,
139 unsigned int val, unsigned int *selector,
140 bool *found)
141{
142 *found = false;
143
144 if (r->min > val)
145 return -EINVAL;
146
147 if (linear_range_get_max_value(r) < val) {
148 *selector = r->max_sel;
149 return 0;
150 }
151
152 *found = true;
153
154 if (r->step == 0)
155 *selector = r->min_sel;
156 else
157 *selector = (val - r->min) / r->step + r->min_sel;
158
159 return 0;
160}
161EXPORT_SYMBOL_GPL(linear_range_get_selector_low);
162
163/**
164 * linear_range_get_selector_low_array - return linear range selector for value
165 * @r: pointer to array of linear ranges where selector is looked from
166 * @ranges: amount of ranges to scan from array
167 * @val: value for which the selector is searched
168 * @selector: address where found selector value is updated
169 * @found: flag to indicate that given value was in the range
170 *
171 * Scan array of ranges for selector for which range value matches given
172 * input value. Value is matching if it is equal or smaller than given
173 * value. If given value is found to be in a range scanning is stopped and
174 * @found is set true. If a range with values smaller than given value is found
175 * but the range max is being smaller than given value, then the range's
176 * biggest selector is updated to @selector but scanning ranges is continued
177 * and @found is set to false.
178 *
179 * Return: 0 on success, -EINVAL if range array is invalid or does not contain
180 * range with a value smaller or equal to given value
181 */
182int linear_range_get_selector_low_array(const struct linear_range *r,
183 int ranges, unsigned int val,
184 unsigned int *selector, bool *found)
185{
186 int i;
187 int ret = -EINVAL;
188
189 for (i = 0; i < ranges; i++) {
190 int tmpret;
191
192 tmpret = linear_range_get_selector_low(&r[i], val, selector,
193 found);
194 if (!tmpret)
195 ret = 0;
196
197 if (*found)
198 break;
199 }
200
201 return ret;
202}
203EXPORT_SYMBOL_GPL(linear_range_get_selector_low_array);
204
205/**
206 * linear_range_get_selector_high - return linear range selector for value
207 * @r: pointer to linear range where selector is looked from
208 * @val: value for which the selector is searched
209 * @selector: address where found selector value is updated
210 * @found: flag to indicate that given value was in the range
211 *
212 * Return selector for which range value is closest match for given
213 * input value. Value is matching if it is equal or higher than given
214 * value. If given value is in the range, then @found is set true.
215 *
216 * Return: 0 on success, -EINVAL if range is invalid or does not contain
217 * value greater or equal to given value
218 */
219int linear_range_get_selector_high(const struct linear_range *r,
220 unsigned int val, unsigned int *selector,
221 bool *found)
222{
223 *found = false;
224
225 if (linear_range_get_max_value(r) < val)
226 return -EINVAL;
227
228 if (r->min > val) {
229 *selector = r->min_sel;
230 return 0;
231 }
232
233 *found = true;
234
235 if (r->step == 0)
236 *selector = r->max_sel;
237 else
238 *selector = DIV_ROUND_UP(val - r->min, r->step) + r->min_sel;
239
240 return 0;
241}
242EXPORT_SYMBOL_GPL(linear_range_get_selector_high);
243
244/**
245 * linear_range_get_selector_high_array - return linear range selector for value
246 * @r: pointer to array of linear ranges where selector is looked from
247 * @ranges: amount of ranges to scan from array
248 * @val: value for which the selector is searched
249 * @selector: address where found selector value is updated
250 * @found: flag to indicate that given value was in the range
251 *
252 * Scan array of ranges for selector for which range value matches given
253 * input value. Value is matching if it is equal or higher than given value
254 * If given value is found to be in a range scanning is stopped and @found is
255 * set true. If a range with values greater than given value is found
256 * but the range min is being greater than given value, then the range's
257 * lowest selector is updated to @selector and scanning is stopped.
258 *
259 * Return: 0 on success, -EINVAL if range array is invalid or does not contain
260 * range with a value greater or equal to given value
261 */
262int linear_range_get_selector_high_array(const struct linear_range *r,
263 int ranges, unsigned int val,
264 unsigned int *selector, bool *found)
265{
266 int i;
267 int ret;
268
269 for (i = 0; i < ranges; i++) {
270 ret = linear_range_get_selector_high(&r[i], val, selector,
271 found);
272 if (!ret)
273 return 0;
274 }
275
276 return -EINVAL;
277}
278EXPORT_SYMBOL_GPL(linear_range_get_selector_high_array);
279
280/**
281 * linear_range_get_selector_within - return linear range selector for value
282 * @r: pointer to linear range where selector is looked from
283 * @val: value for which the selector is searched
284 * @selector: address where found selector value is updated
285 *
286 * Return selector for which range value is closest match for given
287 * input value. Value is matching if it is equal or lower than given
288 * value. But return maximum selector if given value is higher than
289 * maximum value.
290 */
291void linear_range_get_selector_within(const struct linear_range *r,
292 unsigned int val, unsigned int *selector)
293{
294 if (r->min > val) {
295 *selector = r->min_sel;
296 return;
297 }
298
299 if (linear_range_get_max_value(r) < val) {
300 *selector = r->max_sel;
301 return;
302 }
303
304 if (r->step == 0)
305 *selector = r->min_sel;
306 else
307 *selector = (val - r->min) / r->step + r->min_sel;
308}
309EXPORT_SYMBOL_GPL(linear_range_get_selector_within);
310
311MODULE_DESCRIPTION("linear-ranges helper");
312MODULE_LICENSE("GPL");