1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * HID Sensors Driver |
4 | * Copyright (c) 2013, Intel Corporation. |
5 | */ |
6 | |
7 | #include <linux/device.h> |
8 | #include <linux/platform_device.h> |
9 | #include <linux/module.h> |
10 | #include <linux/mod_devicetable.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/hid-sensor-hub.h> |
13 | #include <linux/iio/iio.h> |
14 | #include <linux/iio/buffer.h> |
15 | #include "../common/hid-sensors/hid-sensor-trigger.h" |
16 | |
17 | enum incl_3d_channel { |
18 | CHANNEL_SCAN_INDEX_X, |
19 | CHANNEL_SCAN_INDEX_Y, |
20 | CHANNEL_SCAN_INDEX_Z, |
21 | INCLI_3D_CHANNEL_MAX, |
22 | }; |
23 | |
24 | #define CHANNEL_SCAN_INDEX_TIMESTAMP INCLI_3D_CHANNEL_MAX |
25 | |
26 | struct incl_3d_state { |
27 | struct hid_sensor_hub_callbacks callbacks; |
28 | struct hid_sensor_common common_attributes; |
29 | struct hid_sensor_hub_attribute_info incl[INCLI_3D_CHANNEL_MAX]; |
30 | struct { |
31 | u32 incl_val[INCLI_3D_CHANNEL_MAX]; |
32 | u64 timestamp __aligned(8); |
33 | } scan; |
34 | int scale_pre_decml; |
35 | int scale_post_decml; |
36 | int scale_precision; |
37 | int value_offset; |
38 | s64 timestamp; |
39 | }; |
40 | |
41 | static const u32 incl_3d_addresses[INCLI_3D_CHANNEL_MAX] = { |
42 | HID_USAGE_SENSOR_ORIENT_TILT_X, |
43 | HID_USAGE_SENSOR_ORIENT_TILT_Y, |
44 | HID_USAGE_SENSOR_ORIENT_TILT_Z |
45 | }; |
46 | |
47 | static const u32 incl_3d_sensitivity_addresses[] = { |
48 | HID_USAGE_SENSOR_DATA_ORIENTATION, |
49 | HID_USAGE_SENSOR_ORIENT_TILT, |
50 | }; |
51 | |
52 | /* Channel definitions */ |
53 | static const struct iio_chan_spec incl_3d_channels[] = { |
54 | { |
55 | .type = IIO_INCLI, |
56 | .modified = 1, |
57 | .channel2 = IIO_MOD_X, |
58 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
59 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) | |
60 | BIT(IIO_CHAN_INFO_SCALE) | |
61 | BIT(IIO_CHAN_INFO_SAMP_FREQ) | |
62 | BIT(IIO_CHAN_INFO_HYSTERESIS), |
63 | .scan_index = CHANNEL_SCAN_INDEX_X, |
64 | }, { |
65 | .type = IIO_INCLI, |
66 | .modified = 1, |
67 | .channel2 = IIO_MOD_Y, |
68 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
69 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) | |
70 | BIT(IIO_CHAN_INFO_SCALE) | |
71 | BIT(IIO_CHAN_INFO_SAMP_FREQ) | |
72 | BIT(IIO_CHAN_INFO_HYSTERESIS), |
73 | .scan_index = CHANNEL_SCAN_INDEX_Y, |
74 | }, { |
75 | .type = IIO_INCLI, |
76 | .modified = 1, |
77 | .channel2 = IIO_MOD_Z, |
78 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
79 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) | |
80 | BIT(IIO_CHAN_INFO_SCALE) | |
81 | BIT(IIO_CHAN_INFO_SAMP_FREQ) | |
82 | BIT(IIO_CHAN_INFO_HYSTERESIS), |
83 | .scan_index = CHANNEL_SCAN_INDEX_Z, |
84 | }, |
85 | IIO_CHAN_SOFT_TIMESTAMP(CHANNEL_SCAN_INDEX_TIMESTAMP), |
86 | }; |
87 | |
88 | /* Adjust channel real bits based on report descriptor */ |
89 | static void incl_3d_adjust_channel_bit_mask(struct iio_chan_spec *chan, |
90 | int size) |
91 | { |
92 | chan->scan_type.sign = 's'; |
93 | /* Real storage bits will change based on the report desc. */ |
94 | chan->scan_type.realbits = size * 8; |
95 | /* Maximum size of a sample to capture is u32 */ |
96 | chan->scan_type.storagebits = sizeof(u32) * 8; |
97 | } |
98 | |
99 | /* Channel read_raw handler */ |
100 | static int incl_3d_read_raw(struct iio_dev *indio_dev, |
101 | struct iio_chan_spec const *chan, |
102 | int *val, int *val2, |
103 | long mask) |
104 | { |
105 | struct incl_3d_state *incl_state = iio_priv(indio_dev); |
106 | int report_id = -1; |
107 | u32 address; |
108 | int ret_type; |
109 | s32 min; |
110 | |
111 | *val = 0; |
112 | *val2 = 0; |
113 | switch (mask) { |
114 | case IIO_CHAN_INFO_RAW: |
115 | hid_sensor_power_state(st: &incl_state->common_attributes, state: true); |
116 | report_id = incl_state->incl[chan->scan_index].report_id; |
117 | min = incl_state->incl[chan->scan_index].logical_minimum; |
118 | address = incl_3d_addresses[chan->scan_index]; |
119 | if (report_id >= 0) |
120 | *val = sensor_hub_input_attr_get_raw_value( |
121 | hsdev: incl_state->common_attributes.hsdev, |
122 | HID_USAGE_SENSOR_INCLINOMETER_3D, attr_usage_id: address, |
123 | report_id, |
124 | flag: SENSOR_HUB_SYNC, |
125 | is_signed: min < 0); |
126 | else { |
127 | hid_sensor_power_state(st: &incl_state->common_attributes, |
128 | state: false); |
129 | return -EINVAL; |
130 | } |
131 | hid_sensor_power_state(st: &incl_state->common_attributes, state: false); |
132 | ret_type = IIO_VAL_INT; |
133 | break; |
134 | case IIO_CHAN_INFO_SCALE: |
135 | *val = incl_state->scale_pre_decml; |
136 | *val2 = incl_state->scale_post_decml; |
137 | ret_type = incl_state->scale_precision; |
138 | break; |
139 | case IIO_CHAN_INFO_OFFSET: |
140 | *val = incl_state->value_offset; |
141 | ret_type = IIO_VAL_INT; |
142 | break; |
143 | case IIO_CHAN_INFO_SAMP_FREQ: |
144 | ret_type = hid_sensor_read_samp_freq_value( |
145 | st: &incl_state->common_attributes, val1: val, val2); |
146 | break; |
147 | case IIO_CHAN_INFO_HYSTERESIS: |
148 | ret_type = hid_sensor_read_raw_hyst_value( |
149 | st: &incl_state->common_attributes, val1: val, val2); |
150 | break; |
151 | default: |
152 | ret_type = -EINVAL; |
153 | break; |
154 | } |
155 | |
156 | return ret_type; |
157 | } |
158 | |
159 | /* Channel write_raw handler */ |
160 | static int incl_3d_write_raw(struct iio_dev *indio_dev, |
161 | struct iio_chan_spec const *chan, |
162 | int val, |
163 | int val2, |
164 | long mask) |
165 | { |
166 | struct incl_3d_state *incl_state = iio_priv(indio_dev); |
167 | int ret; |
168 | |
169 | switch (mask) { |
170 | case IIO_CHAN_INFO_SAMP_FREQ: |
171 | ret = hid_sensor_write_samp_freq_value( |
172 | st: &incl_state->common_attributes, val1: val, val2); |
173 | break; |
174 | case IIO_CHAN_INFO_HYSTERESIS: |
175 | ret = hid_sensor_write_raw_hyst_value( |
176 | st: &incl_state->common_attributes, val1: val, val2); |
177 | break; |
178 | default: |
179 | ret = -EINVAL; |
180 | } |
181 | |
182 | return ret; |
183 | } |
184 | |
185 | static const struct iio_info incl_3d_info = { |
186 | .read_raw = &incl_3d_read_raw, |
187 | .write_raw = &incl_3d_write_raw, |
188 | }; |
189 | |
190 | /* Callback handler to send event after all samples are received and captured */ |
191 | static int incl_3d_proc_event(struct hid_sensor_hub_device *hsdev, |
192 | unsigned usage_id, |
193 | void *priv) |
194 | { |
195 | struct iio_dev *indio_dev = platform_get_drvdata(pdev: priv); |
196 | struct incl_3d_state *incl_state = iio_priv(indio_dev); |
197 | |
198 | dev_dbg(&indio_dev->dev, "incl_3d_proc_event\n" ); |
199 | if (atomic_read(v: &incl_state->common_attributes.data_ready)) { |
200 | if (!incl_state->timestamp) |
201 | incl_state->timestamp = iio_get_time_ns(indio_dev); |
202 | |
203 | iio_push_to_buffers_with_timestamp(indio_dev, |
204 | data: &incl_state->scan, |
205 | timestamp: incl_state->timestamp); |
206 | |
207 | incl_state->timestamp = 0; |
208 | } |
209 | |
210 | return 0; |
211 | } |
212 | |
213 | /* Capture samples in local storage */ |
214 | static int incl_3d_capture_sample(struct hid_sensor_hub_device *hsdev, |
215 | unsigned usage_id, |
216 | size_t raw_len, char *raw_data, |
217 | void *priv) |
218 | { |
219 | struct iio_dev *indio_dev = platform_get_drvdata(pdev: priv); |
220 | struct incl_3d_state *incl_state = iio_priv(indio_dev); |
221 | int ret = 0; |
222 | |
223 | switch (usage_id) { |
224 | case HID_USAGE_SENSOR_ORIENT_TILT_X: |
225 | incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_X] = *(u32 *)raw_data; |
226 | break; |
227 | case HID_USAGE_SENSOR_ORIENT_TILT_Y: |
228 | incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_Y] = *(u32 *)raw_data; |
229 | break; |
230 | case HID_USAGE_SENSOR_ORIENT_TILT_Z: |
231 | incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_Z] = *(u32 *)raw_data; |
232 | break; |
233 | case HID_USAGE_SENSOR_TIME_TIMESTAMP: |
234 | incl_state->timestamp = |
235 | hid_sensor_convert_timestamp(st: &incl_state->common_attributes, |
236 | raw_value: *(s64 *)raw_data); |
237 | break; |
238 | default: |
239 | ret = -EINVAL; |
240 | break; |
241 | } |
242 | |
243 | return ret; |
244 | } |
245 | |
246 | /* Parse report which is specific to an usage id*/ |
247 | static int incl_3d_parse_report(struct platform_device *pdev, |
248 | struct hid_sensor_hub_device *hsdev, |
249 | struct iio_chan_spec *channels, |
250 | unsigned usage_id, |
251 | struct incl_3d_state *st) |
252 | { |
253 | int ret; |
254 | |
255 | ret = sensor_hub_input_get_attribute_info(hsdev, |
256 | type: HID_INPUT_REPORT, |
257 | usage_id, |
258 | HID_USAGE_SENSOR_ORIENT_TILT_X, |
259 | info: &st->incl[CHANNEL_SCAN_INDEX_X]); |
260 | if (ret) |
261 | return ret; |
262 | incl_3d_adjust_channel_bit_mask(chan: &channels[CHANNEL_SCAN_INDEX_X], |
263 | size: st->incl[CHANNEL_SCAN_INDEX_X].size); |
264 | |
265 | ret = sensor_hub_input_get_attribute_info(hsdev, |
266 | type: HID_INPUT_REPORT, |
267 | usage_id, |
268 | HID_USAGE_SENSOR_ORIENT_TILT_Y, |
269 | info: &st->incl[CHANNEL_SCAN_INDEX_Y]); |
270 | if (ret) |
271 | return ret; |
272 | incl_3d_adjust_channel_bit_mask(chan: &channels[CHANNEL_SCAN_INDEX_Y], |
273 | size: st->incl[CHANNEL_SCAN_INDEX_Y].size); |
274 | |
275 | ret = sensor_hub_input_get_attribute_info(hsdev, |
276 | type: HID_INPUT_REPORT, |
277 | usage_id, |
278 | HID_USAGE_SENSOR_ORIENT_TILT_Z, |
279 | info: &st->incl[CHANNEL_SCAN_INDEX_Z]); |
280 | if (ret) |
281 | return ret; |
282 | incl_3d_adjust_channel_bit_mask(chan: &channels[CHANNEL_SCAN_INDEX_Z], |
283 | size: st->incl[CHANNEL_SCAN_INDEX_Z].size); |
284 | |
285 | dev_dbg(&pdev->dev, "incl_3d %x:%x, %x:%x, %x:%x\n" , |
286 | st->incl[0].index, |
287 | st->incl[0].report_id, |
288 | st->incl[1].index, st->incl[1].report_id, |
289 | st->incl[2].index, st->incl[2].report_id); |
290 | |
291 | st->scale_precision = hid_sensor_format_scale( |
292 | HID_USAGE_SENSOR_INCLINOMETER_3D, |
293 | attr_info: &st->incl[CHANNEL_SCAN_INDEX_X], |
294 | val0: &st->scale_pre_decml, val1: &st->scale_post_decml); |
295 | |
296 | return ret; |
297 | } |
298 | |
299 | /* Function to initialize the processing for usage id */ |
300 | static int hid_incl_3d_probe(struct platform_device *pdev) |
301 | { |
302 | int ret; |
303 | static char *name = "incli_3d" ; |
304 | struct iio_dev *indio_dev; |
305 | struct incl_3d_state *incl_state; |
306 | struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; |
307 | |
308 | indio_dev = devm_iio_device_alloc(parent: &pdev->dev, |
309 | sizeof_priv: sizeof(struct incl_3d_state)); |
310 | if (indio_dev == NULL) |
311 | return -ENOMEM; |
312 | |
313 | platform_set_drvdata(pdev, data: indio_dev); |
314 | |
315 | incl_state = iio_priv(indio_dev); |
316 | incl_state->common_attributes.hsdev = hsdev; |
317 | incl_state->common_attributes.pdev = pdev; |
318 | |
319 | ret = hid_sensor_parse_common_attributes(hsdev, |
320 | HID_USAGE_SENSOR_INCLINOMETER_3D, |
321 | st: &incl_state->common_attributes, |
322 | sensitivity_addresses: incl_3d_sensitivity_addresses, |
323 | ARRAY_SIZE(incl_3d_sensitivity_addresses)); |
324 | if (ret) { |
325 | dev_err(&pdev->dev, "failed to setup common attributes\n" ); |
326 | return ret; |
327 | } |
328 | |
329 | indio_dev->channels = devm_kmemdup(dev: &pdev->dev, src: incl_3d_channels, |
330 | len: sizeof(incl_3d_channels), GFP_KERNEL); |
331 | if (!indio_dev->channels) { |
332 | dev_err(&pdev->dev, "failed to duplicate channels\n" ); |
333 | return -ENOMEM; |
334 | } |
335 | |
336 | ret = incl_3d_parse_report(pdev, hsdev, |
337 | channels: (struct iio_chan_spec *)indio_dev->channels, |
338 | HID_USAGE_SENSOR_INCLINOMETER_3D, |
339 | st: incl_state); |
340 | if (ret) { |
341 | dev_err(&pdev->dev, "failed to setup attributes\n" ); |
342 | return ret; |
343 | } |
344 | |
345 | indio_dev->num_channels = ARRAY_SIZE(incl_3d_channels); |
346 | indio_dev->info = &incl_3d_info; |
347 | indio_dev->name = name; |
348 | indio_dev->modes = INDIO_DIRECT_MODE; |
349 | |
350 | atomic_set(v: &incl_state->common_attributes.data_ready, i: 0); |
351 | |
352 | ret = hid_sensor_setup_trigger(indio_dev, name, |
353 | attrb: &incl_state->common_attributes); |
354 | if (ret) { |
355 | dev_err(&pdev->dev, "trigger setup failed\n" ); |
356 | return ret; |
357 | } |
358 | |
359 | ret = iio_device_register(indio_dev); |
360 | if (ret) { |
361 | dev_err(&pdev->dev, "device register failed\n" ); |
362 | goto error_remove_trigger; |
363 | } |
364 | |
365 | incl_state->callbacks.send_event = incl_3d_proc_event; |
366 | incl_state->callbacks.capture_sample = incl_3d_capture_sample; |
367 | incl_state->callbacks.pdev = pdev; |
368 | ret = sensor_hub_register_callback(hsdev, |
369 | HID_USAGE_SENSOR_INCLINOMETER_3D, |
370 | usage_callback: &incl_state->callbacks); |
371 | if (ret) { |
372 | dev_err(&pdev->dev, "callback reg failed\n" ); |
373 | goto error_iio_unreg; |
374 | } |
375 | |
376 | return 0; |
377 | |
378 | error_iio_unreg: |
379 | iio_device_unregister(indio_dev); |
380 | error_remove_trigger: |
381 | hid_sensor_remove_trigger(indio_dev, attrb: &incl_state->common_attributes); |
382 | return ret; |
383 | } |
384 | |
385 | /* Function to deinitialize the processing for usage id */ |
386 | static void hid_incl_3d_remove(struct platform_device *pdev) |
387 | { |
388 | struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; |
389 | struct iio_dev *indio_dev = platform_get_drvdata(pdev); |
390 | struct incl_3d_state *incl_state = iio_priv(indio_dev); |
391 | |
392 | sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_INCLINOMETER_3D); |
393 | iio_device_unregister(indio_dev); |
394 | hid_sensor_remove_trigger(indio_dev, attrb: &incl_state->common_attributes); |
395 | } |
396 | |
397 | static const struct platform_device_id hid_incl_3d_ids[] = { |
398 | { |
399 | /* Format: HID-SENSOR-usage_id_in_hex_lowercase */ |
400 | .name = "HID-SENSOR-200086" , |
401 | }, |
402 | { /* sentinel */ } |
403 | }; |
404 | MODULE_DEVICE_TABLE(platform, hid_incl_3d_ids); |
405 | |
406 | static struct platform_driver hid_incl_3d_platform_driver = { |
407 | .id_table = hid_incl_3d_ids, |
408 | .driver = { |
409 | .name = KBUILD_MODNAME, |
410 | .pm = &hid_sensor_pm_ops, |
411 | }, |
412 | .probe = hid_incl_3d_probe, |
413 | .remove_new = hid_incl_3d_remove, |
414 | }; |
415 | module_platform_driver(hid_incl_3d_platform_driver); |
416 | |
417 | MODULE_DESCRIPTION("HID Sensor Inclinometer 3D" ); |
418 | MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>" ); |
419 | MODULE_LICENSE("GPL" ); |
420 | MODULE_IMPORT_NS(IIO_HID); |
421 | |