1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/device.h>
20#include <linux/platform_device.h>
21#include <linux/module.h>
22#include <linux/interrupt.h>
23#include <linux/irq.h>
24#include <linux/slab.h>
25#include <linux/hid-sensor-hub.h>
26#include <linux/iio/iio.h>
27#include <linux/iio/sysfs.h>
28
29static int pow_10(unsigned power)
30{
31 int i;
32 int ret = 1;
33 for (i = 0; i < power; ++i)
34 ret = ret * 10;
35
36 return ret;
37}
38
39static void simple_div(int dividend, int divisor, int *whole,
40 int *micro_frac)
41{
42 int rem;
43 int exp = 0;
44
45 *micro_frac = 0;
46 if (divisor == 0) {
47 *whole = 0;
48 return;
49 }
50 *whole = dividend/divisor;
51 rem = dividend % divisor;
52 if (rem) {
53 while (rem <= divisor) {
54 rem *= 10;
55 exp++;
56 }
57 *micro_frac = (rem / divisor) * pow_10(6-exp);
58 }
59}
60
61static void split_micro_fraction(unsigned int no, int exp, int *val1, int *val2)
62{
63 *val1 = no/pow_10(exp);
64 *val2 = no%pow_10(exp) * pow_10(6-exp);
65}
66
67
68
69
70
71
72
73
74
75static void convert_from_vtf_format(u32 value, int size, int exp,
76 int *val1, int *val2)
77{
78 int sign = 1;
79
80 if (value & BIT(size*8 - 1)) {
81 value = ((1LL << (size * 8)) - value);
82 sign = -1;
83 }
84 exp = hid_sensor_convert_exponent(exp);
85 if (exp >= 0) {
86 *val1 = sign * value * pow_10(exp);
87 *val2 = 0;
88 } else {
89 split_micro_fraction(value, -exp, val1, val2);
90 if (*val1)
91 *val1 = sign * (*val1);
92 else
93 *val2 = sign * (*val2);
94 }
95}
96
97static u32 convert_to_vtf_format(int size, int exp, int val1, int val2)
98{
99 u32 value;
100 int sign = 1;
101
102 if (val1 < 0 || val2 < 0)
103 sign = -1;
104 exp = hid_sensor_convert_exponent(exp);
105 if (exp < 0) {
106 value = abs(val1) * pow_10(-exp);
107 value += abs(val2) / pow_10(6+exp);
108 } else
109 value = abs(val1) / pow_10(exp);
110 if (sign < 0)
111 value = ((1LL << (size * 8)) - value);
112
113 return value;
114}
115
116int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st,
117 int *val1, int *val2)
118{
119 s32 value;
120 int ret;
121
122 ret = sensor_hub_get_feature(st->hsdev,
123 st->poll.report_id,
124 st->poll.index, &value);
125 if (ret < 0 || value < 0) {
126 *val1 = *val2 = 0;
127 return -EINVAL;
128 } else {
129 if (st->poll.units == HID_USAGE_SENSOR_UNITS_MILLISECOND)
130 simple_div(1000, value, val1, val2);
131 else if (st->poll.units == HID_USAGE_SENSOR_UNITS_SECOND)
132 simple_div(1, value, val1, val2);
133 else {
134 *val1 = *val2 = 0;
135 return -EINVAL;
136 }
137 }
138
139 return IIO_VAL_INT_PLUS_MICRO;
140}
141EXPORT_SYMBOL(hid_sensor_read_samp_freq_value);
142
143int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st,
144 int val1, int val2)
145{
146 s32 value;
147 int ret;
148
149 if (val1 < 0 || val2 < 0)
150 ret = -EINVAL;
151
152 value = val1 * pow_10(6) + val2;
153 if (value) {
154 if (st->poll.units == HID_USAGE_SENSOR_UNITS_MILLISECOND)
155 value = pow_10(9)/value;
156 else if (st->poll.units == HID_USAGE_SENSOR_UNITS_SECOND)
157 value = pow_10(6)/value;
158 else
159 value = 0;
160 }
161 ret = sensor_hub_set_feature(st->hsdev,
162 st->poll.report_id,
163 st->poll.index, value);
164 if (ret < 0 || value < 0)
165 ret = -EINVAL;
166
167 return ret;
168}
169EXPORT_SYMBOL(hid_sensor_write_samp_freq_value);
170
171int hid_sensor_read_raw_hyst_value(struct hid_sensor_common *st,
172 int *val1, int *val2)
173{
174 s32 value;
175 int ret;
176
177 ret = sensor_hub_get_feature(st->hsdev,
178 st->sensitivity.report_id,
179 st->sensitivity.index, &value);
180 if (ret < 0 || value < 0) {
181 *val1 = *val2 = 0;
182 return -EINVAL;
183 } else {
184 convert_from_vtf_format(value, st->sensitivity.size,
185 st->sensitivity.unit_expo,
186 val1, val2);
187 }
188
189 return IIO_VAL_INT_PLUS_MICRO;
190}
191EXPORT_SYMBOL(hid_sensor_read_raw_hyst_value);
192
193int hid_sensor_write_raw_hyst_value(struct hid_sensor_common *st,
194 int val1, int val2)
195{
196 s32 value;
197 int ret;
198
199 value = convert_to_vtf_format(st->sensitivity.size,
200 st->sensitivity.unit_expo,
201 val1, val2);
202 ret = sensor_hub_set_feature(st->hsdev,
203 st->sensitivity.report_id,
204 st->sensitivity.index, value);
205 if (ret < 0 || value < 0)
206 ret = -EINVAL;
207
208 return ret;
209}
210EXPORT_SYMBOL(hid_sensor_write_raw_hyst_value);
211
212int hid_sensor_parse_common_attributes(struct hid_sensor_hub_device *hsdev,
213 u32 usage_id,
214 struct hid_sensor_common *st)
215{
216
217 sensor_hub_input_get_attribute_info(hsdev,
218 HID_FEATURE_REPORT, usage_id,
219 HID_USAGE_SENSOR_PROP_REPORT_INTERVAL,
220 &st->poll);
221
222 sensor_hub_input_get_attribute_info(hsdev,
223 HID_FEATURE_REPORT, usage_id,
224 HID_USAGE_SENSOR_PROP_REPORT_STATE,
225 &st->report_state);
226
227 sensor_hub_input_get_attribute_info(hsdev,
228 HID_FEATURE_REPORT, usage_id,
229 HID_USAGE_SENSOR_PROY_POWER_STATE,
230 &st->power_state);
231
232 sensor_hub_input_get_attribute_info(hsdev,
233 HID_FEATURE_REPORT, usage_id,
234 HID_USAGE_SENSOR_PROP_SENSITIVITY_ABS,
235 &st->sensitivity);
236
237 hid_dbg(hsdev->hdev, "common attributes: %x:%x, %x:%x, %x:%x %x:%x\n",
238 st->poll.index, st->poll.report_id,
239 st->report_state.index, st->report_state.report_id,
240 st->power_state.index, st->power_state.report_id,
241 st->sensitivity.index, st->sensitivity.report_id);
242
243 return 0;
244}
245EXPORT_SYMBOL(hid_sensor_parse_common_attributes);
246
247MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
248MODULE_DESCRIPTION("HID Sensor common attribute processing");
249MODULE_LICENSE("GPL");
250
