1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * hid-sensor-custom.c |
4 | * Copyright (c) 2015, Intel Corporation. |
5 | */ |
6 | |
7 | #include <linux/ctype.h> |
8 | #include <linux/dmi.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/module.h> |
11 | #include <linux/init.h> |
12 | #include <linux/miscdevice.h> |
13 | #include <linux/kfifo.h> |
14 | #include <linux/sched.h> |
15 | #include <linux/wait.h> |
16 | #include <linux/poll.h> |
17 | #include <linux/bsearch.h> |
18 | #include <linux/platform_device.h> |
19 | #include <linux/hid-sensor-hub.h> |
20 | |
21 | #define HID_CUSTOM_NAME_LENGTH 64 |
22 | #define HID_CUSTOM_MAX_CORE_ATTRS 10 |
23 | #define HID_CUSTOM_TOTAL_ATTRS (HID_CUSTOM_MAX_CORE_ATTRS + 1) |
24 | #define HID_CUSTOM_FIFO_SIZE 4096 |
25 | #define HID_CUSTOM_MAX_FEATURE_BYTES 64 |
26 | #define HID_SENSOR_USAGE_LENGTH (4 + 1) |
27 | |
28 | struct hid_sensor_custom_field { |
29 | int report_id; |
30 | char group_name[HID_CUSTOM_NAME_LENGTH]; |
31 | struct hid_sensor_hub_attribute_info attribute; |
32 | struct device_attribute sd_attrs[HID_CUSTOM_MAX_CORE_ATTRS]; |
33 | char attr_name[HID_CUSTOM_TOTAL_ATTRS][HID_CUSTOM_NAME_LENGTH]; |
34 | struct attribute *attrs[HID_CUSTOM_TOTAL_ATTRS]; |
35 | struct attribute_group hid_custom_attribute_group; |
36 | }; |
37 | |
38 | struct hid_sensor_custom { |
39 | struct mutex mutex; |
40 | struct platform_device *pdev; |
41 | struct hid_sensor_hub_device *hsdev; |
42 | struct hid_sensor_hub_callbacks callbacks; |
43 | int sensor_field_count; |
44 | struct hid_sensor_custom_field *fields; |
45 | int input_field_count; |
46 | int input_report_size; |
47 | int input_report_recd_size; |
48 | bool input_skip_sample; |
49 | bool enable; |
50 | struct hid_sensor_custom_field *power_state; |
51 | struct hid_sensor_custom_field *report_state; |
52 | struct miscdevice custom_dev; |
53 | struct kfifo data_fifo; |
54 | unsigned long misc_opened; |
55 | wait_queue_head_t wait; |
56 | struct platform_device *custom_pdev; |
57 | }; |
58 | |
59 | /* Header for each sample to user space via dev interface */ |
60 | struct hid_sensor_sample { |
61 | u32 usage_id; |
62 | u64 timestamp; |
63 | u32 raw_len; |
64 | } __packed; |
65 | |
66 | static struct attribute hid_custom_attrs[HID_CUSTOM_TOTAL_ATTRS] = { |
67 | {.name = "name" , .mode = S_IRUGO}, |
68 | {.name = "units" , .mode = S_IRUGO}, |
69 | {.name = "unit-expo" , .mode = S_IRUGO}, |
70 | {.name = "minimum" , .mode = S_IRUGO}, |
71 | {.name = "maximum" , .mode = S_IRUGO}, |
72 | {.name = "size" , .mode = S_IRUGO}, |
73 | {.name = "value" , .mode = S_IWUSR | S_IRUGO}, |
74 | {.name = NULL} |
75 | }; |
76 | |
77 | static const struct hid_custom_usage_desc { |
78 | int usage_id; |
79 | char *desc; |
80 | } hid_custom_usage_desc_table[] = { |
81 | {0x200201, "event-sensor-state" }, |
82 | {0x200202, "event-sensor-event" }, |
83 | {0x200301, "property-friendly-name" }, |
84 | {0x200302, "property-persistent-unique-id" }, |
85 | {0x200303, "property-sensor-status" }, |
86 | {0x200304, "property-min-report-interval" }, |
87 | {0x200305, "property-sensor-manufacturer" }, |
88 | {0x200306, "property-sensor-model" }, |
89 | {0x200307, "property-sensor-serial-number" }, |
90 | {0x200308, "property-sensor-description" }, |
91 | {0x200309, "property-sensor-connection-type" }, |
92 | {0x20030A, "property-sensor-device-path" }, |
93 | {0x20030B, "property-hardware-revision" }, |
94 | {0x20030C, "property-firmware-version" }, |
95 | {0x20030D, "property-release-date" }, |
96 | {0x20030E, "property-report-interval" }, |
97 | {0x20030F, "property-change-sensitivity-absolute" }, |
98 | {0x200310, "property-change-sensitivity-percent-range" }, |
99 | {0x200311, "property-change-sensitivity-percent-relative" }, |
100 | {0x200312, "property-accuracy" }, |
101 | {0x200313, "property-resolution" }, |
102 | {0x200314, "property-maximum" }, |
103 | {0x200315, "property-minimum" }, |
104 | {0x200316, "property-reporting-state" }, |
105 | {0x200317, "property-sampling-rate" }, |
106 | {0x200318, "property-response-curve" }, |
107 | {0x200319, "property-power-state" }, |
108 | {0x200540, "data-field-custom" }, |
109 | {0x200541, "data-field-custom-usage" }, |
110 | {0x200542, "data-field-custom-boolean-array" }, |
111 | {0x200543, "data-field-custom-value" }, |
112 | {0x200544, "data-field-custom-value_1" }, |
113 | {0x200545, "data-field-custom-value_2" }, |
114 | {0x200546, "data-field-custom-value_3" }, |
115 | {0x200547, "data-field-custom-value_4" }, |
116 | {0x200548, "data-field-custom-value_5" }, |
117 | {0x200549, "data-field-custom-value_6" }, |
118 | {0x20054A, "data-field-custom-value_7" }, |
119 | {0x20054B, "data-field-custom-value_8" }, |
120 | {0x20054C, "data-field-custom-value_9" }, |
121 | {0x20054D, "data-field-custom-value_10" }, |
122 | {0x20054E, "data-field-custom-value_11" }, |
123 | {0x20054F, "data-field-custom-value_12" }, |
124 | {0x200550, "data-field-custom-value_13" }, |
125 | {0x200551, "data-field-custom-value_14" }, |
126 | {0x200552, "data-field-custom-value_15" }, |
127 | {0x200553, "data-field-custom-value_16" }, |
128 | {0x200554, "data-field-custom-value_17" }, |
129 | {0x200555, "data-field-custom-value_18" }, |
130 | {0x200556, "data-field-custom-value_19" }, |
131 | {0x200557, "data-field-custom-value_20" }, |
132 | {0x200558, "data-field-custom-value_21" }, |
133 | {0x200559, "data-field-custom-value_22" }, |
134 | {0x20055A, "data-field-custom-value_23" }, |
135 | {0x20055B, "data-field-custom-value_24" }, |
136 | {0x20055C, "data-field-custom-value_25" }, |
137 | {0x20055D, "data-field-custom-value_26" }, |
138 | {0x20055E, "data-field-custom-value_27" }, |
139 | {0x20055F, "data-field-custom-value_28" }, |
140 | }; |
141 | |
142 | static int usage_id_cmp(const void *p1, const void *p2) |
143 | { |
144 | if (*(int *)p1 < *(int *)p2) |
145 | return -1; |
146 | |
147 | if (*(int *)p1 > *(int *)p2) |
148 | return 1; |
149 | |
150 | return 0; |
151 | } |
152 | |
153 | static ssize_t enable_sensor_show(struct device *dev, |
154 | struct device_attribute *attr, char *buf) |
155 | { |
156 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
157 | |
158 | return sprintf(buf, fmt: "%d\n" , sensor_inst->enable); |
159 | } |
160 | |
161 | static int set_power_report_state(struct hid_sensor_custom *sensor_inst, |
162 | bool state) |
163 | { |
164 | int power_val = -1; |
165 | int report_val = -1; |
166 | u32 power_state_usage_id; |
167 | u32 report_state_usage_id; |
168 | int ret; |
169 | |
170 | /* |
171 | * It is possible that the power/report state ids are not present. |
172 | * In this case this function will return success. But if the |
173 | * ids are present, then it will return error if set fails. |
174 | */ |
175 | if (state) { |
176 | power_state_usage_id = |
177 | HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM; |
178 | report_state_usage_id = |
179 | HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM; |
180 | } else { |
181 | power_state_usage_id = |
182 | HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM; |
183 | report_state_usage_id = |
184 | HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM; |
185 | } |
186 | |
187 | if (sensor_inst->power_state) |
188 | power_val = hid_sensor_get_usage_index(hsdev: sensor_inst->hsdev, |
189 | report_id: sensor_inst->power_state->attribute.report_id, |
190 | field_index: sensor_inst->power_state->attribute.index, |
191 | usage_id: power_state_usage_id); |
192 | if (sensor_inst->report_state) |
193 | report_val = hid_sensor_get_usage_index(hsdev: sensor_inst->hsdev, |
194 | report_id: sensor_inst->report_state->attribute.report_id, |
195 | field_index: sensor_inst->report_state->attribute.index, |
196 | usage_id: report_state_usage_id); |
197 | |
198 | if (power_val >= 0) { |
199 | power_val += |
200 | sensor_inst->power_state->attribute.logical_minimum; |
201 | ret = sensor_hub_set_feature(hsdev: sensor_inst->hsdev, |
202 | report_id: sensor_inst->power_state->attribute.report_id, |
203 | field_index: sensor_inst->power_state->attribute.index, |
204 | buffer_size: sizeof(power_val), |
205 | buffer: &power_val); |
206 | if (ret) { |
207 | hid_err(sensor_inst->hsdev->hdev, |
208 | "Set power state failed\n" ); |
209 | return ret; |
210 | } |
211 | } |
212 | |
213 | if (report_val >= 0) { |
214 | report_val += |
215 | sensor_inst->report_state->attribute.logical_minimum; |
216 | ret = sensor_hub_set_feature(hsdev: sensor_inst->hsdev, |
217 | report_id: sensor_inst->report_state->attribute.report_id, |
218 | field_index: sensor_inst->report_state->attribute.index, |
219 | buffer_size: sizeof(report_val), |
220 | buffer: &report_val); |
221 | if (ret) { |
222 | hid_err(sensor_inst->hsdev->hdev, |
223 | "Set report state failed\n" ); |
224 | return ret; |
225 | } |
226 | } |
227 | |
228 | return 0; |
229 | } |
230 | |
231 | static ssize_t enable_sensor_store(struct device *dev, |
232 | struct device_attribute *attr, |
233 | const char *buf, size_t count) |
234 | { |
235 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
236 | int value; |
237 | int ret = -EINVAL; |
238 | |
239 | if (kstrtoint(s: buf, base: 0, res: &value) != 0) |
240 | return -EINVAL; |
241 | |
242 | mutex_lock(&sensor_inst->mutex); |
243 | if (value && !sensor_inst->enable) { |
244 | ret = sensor_hub_device_open(hsdev: sensor_inst->hsdev); |
245 | if (ret) |
246 | goto unlock_state; |
247 | |
248 | ret = set_power_report_state(sensor_inst, state: true); |
249 | if (ret) { |
250 | sensor_hub_device_close(hsdev: sensor_inst->hsdev); |
251 | goto unlock_state; |
252 | } |
253 | sensor_inst->enable = true; |
254 | } else if (!value && sensor_inst->enable) { |
255 | ret = set_power_report_state(sensor_inst, state: false); |
256 | sensor_hub_device_close(hsdev: sensor_inst->hsdev); |
257 | sensor_inst->enable = false; |
258 | } |
259 | unlock_state: |
260 | mutex_unlock(lock: &sensor_inst->mutex); |
261 | if (ret < 0) |
262 | return ret; |
263 | |
264 | return count; |
265 | } |
266 | static DEVICE_ATTR_RW(enable_sensor); |
267 | |
268 | static struct attribute *enable_sensor_attrs[] = { |
269 | &dev_attr_enable_sensor.attr, |
270 | NULL, |
271 | }; |
272 | |
273 | static const struct attribute_group enable_sensor_attr_group = { |
274 | .attrs = enable_sensor_attrs, |
275 | }; |
276 | |
277 | static ssize_t show_value(struct device *dev, struct device_attribute *attr, |
278 | char *buf) |
279 | { |
280 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
281 | struct hid_sensor_hub_attribute_info *attribute; |
282 | int index, usage, field_index; |
283 | char name[HID_CUSTOM_NAME_LENGTH]; |
284 | bool feature = false; |
285 | bool input = false; |
286 | int value = 0; |
287 | |
288 | if (sscanf(attr->attr.name, "feature-%x-%x-%s" , &index, &usage, |
289 | name) == 3) { |
290 | feature = true; |
291 | field_index = index + sensor_inst->input_field_count; |
292 | } else if (sscanf(attr->attr.name, "input-%x-%x-%s" , &index, &usage, |
293 | name) == 3) { |
294 | input = true; |
295 | field_index = index; |
296 | } else |
297 | return -EINVAL; |
298 | |
299 | if (!strncmp(name, "value" , strlen("value" ))) { |
300 | u32 report_id; |
301 | int ret; |
302 | |
303 | attribute = &sensor_inst->fields[field_index].attribute; |
304 | report_id = attribute->report_id; |
305 | if (feature) { |
306 | u8 values[HID_CUSTOM_MAX_FEATURE_BYTES]; |
307 | int len = 0; |
308 | u64 value = 0; |
309 | int i = 0; |
310 | |
311 | ret = sensor_hub_get_feature(hsdev: sensor_inst->hsdev, |
312 | report_id, |
313 | field_index: index, |
314 | buffer_size: sizeof(values), buffer: values); |
315 | if (ret < 0) |
316 | return ret; |
317 | |
318 | while (i < ret) { |
319 | if (i + attribute->size > ret) { |
320 | len += scnprintf(buf: &buf[len], |
321 | PAGE_SIZE - len, |
322 | fmt: "%d " , values[i]); |
323 | break; |
324 | } |
325 | switch (attribute->size) { |
326 | case 2: |
327 | value = (u64) *(u16 *)&values[i]; |
328 | i += attribute->size; |
329 | break; |
330 | case 4: |
331 | value = (u64) *(u32 *)&values[i]; |
332 | i += attribute->size; |
333 | break; |
334 | case 8: |
335 | value = *(u64 *)&values[i]; |
336 | i += attribute->size; |
337 | break; |
338 | default: |
339 | value = (u64) values[i]; |
340 | ++i; |
341 | break; |
342 | } |
343 | len += scnprintf(buf: &buf[len], PAGE_SIZE - len, |
344 | fmt: "%lld " , value); |
345 | } |
346 | len += scnprintf(buf: &buf[len], PAGE_SIZE - len, fmt: "\n" ); |
347 | |
348 | return len; |
349 | } else if (input) |
350 | value = sensor_hub_input_attr_get_raw_value( |
351 | hsdev: sensor_inst->hsdev, |
352 | usage_id: sensor_inst->hsdev->usage, |
353 | attr_usage_id: usage, report_id, |
354 | flag: SENSOR_HUB_SYNC, is_signed: false); |
355 | } else if (!strncmp(name, "units" , strlen("units" ))) |
356 | value = sensor_inst->fields[field_index].attribute.units; |
357 | else if (!strncmp(name, "unit-expo" , strlen("unit-expo" ))) |
358 | value = sensor_inst->fields[field_index].attribute.unit_expo; |
359 | else if (!strncmp(name, "size" , strlen("size" ))) |
360 | value = sensor_inst->fields[field_index].attribute.size; |
361 | else if (!strncmp(name, "minimum" , strlen("minimum" ))) |
362 | value = sensor_inst->fields[field_index].attribute. |
363 | logical_minimum; |
364 | else if (!strncmp(name, "maximum" , strlen("maximum" ))) |
365 | value = sensor_inst->fields[field_index].attribute. |
366 | logical_maximum; |
367 | else if (!strncmp(name, "name" , strlen("name" ))) { |
368 | struct hid_custom_usage_desc *usage_desc; |
369 | |
370 | usage_desc = bsearch(key: &usage, base: hid_custom_usage_desc_table, |
371 | ARRAY_SIZE(hid_custom_usage_desc_table), |
372 | size: sizeof(struct hid_custom_usage_desc), |
373 | cmp: usage_id_cmp); |
374 | if (usage_desc) |
375 | return snprintf(buf, PAGE_SIZE, fmt: "%s\n" , |
376 | usage_desc->desc); |
377 | else |
378 | return sprintf(buf, fmt: "not-specified\n" ); |
379 | } else |
380 | return -EINVAL; |
381 | |
382 | return sprintf(buf, fmt: "%d\n" , value); |
383 | } |
384 | |
385 | static ssize_t store_value(struct device *dev, struct device_attribute *attr, |
386 | const char *buf, size_t count) |
387 | { |
388 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
389 | int index, field_index, usage; |
390 | char name[HID_CUSTOM_NAME_LENGTH]; |
391 | int value, ret; |
392 | |
393 | if (sscanf(attr->attr.name, "feature-%x-%x-%s" , &index, &usage, |
394 | name) == 3) { |
395 | field_index = index + sensor_inst->input_field_count; |
396 | } else |
397 | return -EINVAL; |
398 | |
399 | if (!strncmp(name, "value" , strlen("value" ))) { |
400 | u32 report_id; |
401 | |
402 | if (kstrtoint(s: buf, base: 0, res: &value) != 0) |
403 | return -EINVAL; |
404 | |
405 | report_id = sensor_inst->fields[field_index].attribute. |
406 | report_id; |
407 | ret = sensor_hub_set_feature(hsdev: sensor_inst->hsdev, report_id, |
408 | field_index: index, buffer_size: sizeof(value), buffer: &value); |
409 | if (ret) |
410 | return ret; |
411 | } else |
412 | return -EINVAL; |
413 | |
414 | return count; |
415 | } |
416 | |
417 | static int hid_sensor_capture_sample(struct hid_sensor_hub_device *hsdev, |
418 | unsigned usage_id, size_t raw_len, |
419 | char *raw_data, void *priv) |
420 | { |
421 | struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev: priv); |
422 | struct hid_sensor_sample ; |
423 | |
424 | /* If any error occurs in a sample, rest of the fields are ignored */ |
425 | if (sensor_inst->input_skip_sample) { |
426 | hid_err(sensor_inst->hsdev->hdev, "Skipped remaining data\n" ); |
427 | return 0; |
428 | } |
429 | |
430 | hid_dbg(sensor_inst->hsdev->hdev, "%s received %d of %d\n" , __func__, |
431 | (int) (sensor_inst->input_report_recd_size + raw_len), |
432 | sensor_inst->input_report_size); |
433 | |
434 | if (!test_bit(0, &sensor_inst->misc_opened)) |
435 | return 0; |
436 | |
437 | if (!sensor_inst->input_report_recd_size) { |
438 | int required_size = sizeof(struct hid_sensor_sample) + |
439 | sensor_inst->input_report_size; |
440 | header.usage_id = hsdev->usage; |
441 | header.raw_len = sensor_inst->input_report_size; |
442 | header.timestamp = ktime_get_real_ns(); |
443 | if (kfifo_avail(&sensor_inst->data_fifo) >= required_size) { |
444 | kfifo_in(&sensor_inst->data_fifo, |
445 | (unsigned char *)&header, |
446 | sizeof(header)); |
447 | } else |
448 | sensor_inst->input_skip_sample = true; |
449 | } |
450 | if (kfifo_avail(&sensor_inst->data_fifo) >= raw_len) |
451 | kfifo_in(&sensor_inst->data_fifo, (unsigned char *)raw_data, |
452 | raw_len); |
453 | |
454 | sensor_inst->input_report_recd_size += raw_len; |
455 | |
456 | return 0; |
457 | } |
458 | |
459 | static int hid_sensor_send_event(struct hid_sensor_hub_device *hsdev, |
460 | unsigned usage_id, void *priv) |
461 | { |
462 | struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev: priv); |
463 | |
464 | if (!test_bit(0, &sensor_inst->misc_opened)) |
465 | return 0; |
466 | |
467 | sensor_inst->input_report_recd_size = 0; |
468 | sensor_inst->input_skip_sample = false; |
469 | |
470 | wake_up(&sensor_inst->wait); |
471 | |
472 | return 0; |
473 | } |
474 | |
475 | static int hid_sensor_custom_add_field(struct hid_sensor_custom *sensor_inst, |
476 | int index, int report_type, |
477 | struct hid_report *report, |
478 | struct hid_field *field) |
479 | { |
480 | struct hid_sensor_custom_field *sensor_field; |
481 | void *fields; |
482 | |
483 | fields = krealloc(objp: sensor_inst->fields, |
484 | new_size: (sensor_inst->sensor_field_count + 1) * |
485 | sizeof(struct hid_sensor_custom_field), GFP_KERNEL); |
486 | if (!fields) { |
487 | kfree(objp: sensor_inst->fields); |
488 | return -ENOMEM; |
489 | } |
490 | sensor_inst->fields = fields; |
491 | sensor_field = &sensor_inst->fields[sensor_inst->sensor_field_count]; |
492 | sensor_field->attribute.usage_id = sensor_inst->hsdev->usage; |
493 | if (field->logical) |
494 | sensor_field->attribute.attrib_id = field->logical; |
495 | else |
496 | sensor_field->attribute.attrib_id = field->usage[0].hid; |
497 | |
498 | sensor_field->attribute.index = index; |
499 | sensor_field->attribute.report_id = report->id; |
500 | sensor_field->attribute.units = field->unit; |
501 | sensor_field->attribute.unit_expo = field->unit_exponent; |
502 | sensor_field->attribute.size = (field->report_size / 8); |
503 | sensor_field->attribute.logical_minimum = field->logical_minimum; |
504 | sensor_field->attribute.logical_maximum = field->logical_maximum; |
505 | |
506 | if (report_type == HID_FEATURE_REPORT) |
507 | snprintf(buf: sensor_field->group_name, |
508 | size: sizeof(sensor_field->group_name), fmt: "feature-%x-%x" , |
509 | sensor_field->attribute.index, |
510 | sensor_field->attribute.attrib_id); |
511 | else if (report_type == HID_INPUT_REPORT) { |
512 | snprintf(buf: sensor_field->group_name, |
513 | size: sizeof(sensor_field->group_name), |
514 | fmt: "input-%x-%x" , sensor_field->attribute.index, |
515 | sensor_field->attribute.attrib_id); |
516 | sensor_inst->input_field_count++; |
517 | sensor_inst->input_report_size += (field->report_size * |
518 | field->report_count) / 8; |
519 | } |
520 | |
521 | memset(&sensor_field->hid_custom_attribute_group, 0, |
522 | sizeof(struct attribute_group)); |
523 | sensor_inst->sensor_field_count++; |
524 | |
525 | return 0; |
526 | } |
527 | |
528 | static int hid_sensor_custom_add_fields(struct hid_sensor_custom *sensor_inst, |
529 | struct hid_report_enum *report_enum, |
530 | int report_type) |
531 | { |
532 | int i; |
533 | int ret; |
534 | struct hid_report *report; |
535 | struct hid_field *field; |
536 | struct hid_sensor_hub_device *hsdev = sensor_inst->hsdev; |
537 | |
538 | list_for_each_entry(report, &report_enum->report_list, list) { |
539 | for (i = 0; i < report->maxfield; ++i) { |
540 | field = report->field[i]; |
541 | if (field->maxusage && |
542 | ((field->usage[0].collection_index >= |
543 | hsdev->start_collection_index) && |
544 | (field->usage[0].collection_index < |
545 | hsdev->end_collection_index))) { |
546 | |
547 | ret = hid_sensor_custom_add_field(sensor_inst, |
548 | index: i, |
549 | report_type, |
550 | report, |
551 | field); |
552 | if (ret) |
553 | return ret; |
554 | |
555 | } |
556 | } |
557 | } |
558 | |
559 | return 0; |
560 | } |
561 | |
562 | static int hid_sensor_custom_add_attributes(struct hid_sensor_custom |
563 | *sensor_inst) |
564 | { |
565 | struct hid_sensor_hub_device *hsdev = sensor_inst->hsdev; |
566 | struct hid_device *hdev = hsdev->hdev; |
567 | int ret = -1; |
568 | int i, j; |
569 | |
570 | for (j = 0; j < HID_REPORT_TYPES; ++j) { |
571 | if (j == HID_OUTPUT_REPORT) |
572 | continue; |
573 | |
574 | ret = hid_sensor_custom_add_fields(sensor_inst, |
575 | report_enum: &hdev->report_enum[j], report_type: j); |
576 | if (ret) |
577 | return ret; |
578 | |
579 | } |
580 | |
581 | /* Create sysfs attributes */ |
582 | for (i = 0; i < sensor_inst->sensor_field_count; ++i) { |
583 | j = 0; |
584 | while (j < HID_CUSTOM_TOTAL_ATTRS && |
585 | hid_custom_attrs[j].name) { |
586 | struct device_attribute *device_attr; |
587 | |
588 | device_attr = &sensor_inst->fields[i].sd_attrs[j]; |
589 | |
590 | snprintf(buf: (char *)&sensor_inst->fields[i].attr_name[j], |
591 | HID_CUSTOM_NAME_LENGTH, fmt: "%s-%s" , |
592 | sensor_inst->fields[i].group_name, |
593 | hid_custom_attrs[j].name); |
594 | sysfs_attr_init(&device_attr->attr); |
595 | device_attr->attr.name = |
596 | (char *)&sensor_inst->fields[i].attr_name[j]; |
597 | device_attr->attr.mode = hid_custom_attrs[j].mode; |
598 | device_attr->show = show_value; |
599 | if (hid_custom_attrs[j].mode & S_IWUSR) |
600 | device_attr->store = store_value; |
601 | sensor_inst->fields[i].attrs[j] = &device_attr->attr; |
602 | ++j; |
603 | } |
604 | sensor_inst->fields[i].attrs[j] = NULL; |
605 | sensor_inst->fields[i].hid_custom_attribute_group.attrs = |
606 | sensor_inst->fields[i].attrs; |
607 | sensor_inst->fields[i].hid_custom_attribute_group.name = |
608 | sensor_inst->fields[i].group_name; |
609 | ret = sysfs_create_group(kobj: &sensor_inst->pdev->dev.kobj, |
610 | grp: &sensor_inst->fields[i]. |
611 | hid_custom_attribute_group); |
612 | if (ret) |
613 | break; |
614 | |
615 | /* For power or report field store indexes */ |
616 | if (sensor_inst->fields[i].attribute.attrib_id == |
617 | HID_USAGE_SENSOR_PROY_POWER_STATE) |
618 | sensor_inst->power_state = &sensor_inst->fields[i]; |
619 | else if (sensor_inst->fields[i].attribute.attrib_id == |
620 | HID_USAGE_SENSOR_PROP_REPORT_STATE) |
621 | sensor_inst->report_state = &sensor_inst->fields[i]; |
622 | } |
623 | |
624 | return ret; |
625 | } |
626 | |
627 | static void hid_sensor_custom_remove_attributes(struct hid_sensor_custom * |
628 | sensor_inst) |
629 | { |
630 | int i; |
631 | |
632 | for (i = 0; i < sensor_inst->sensor_field_count; ++i) |
633 | sysfs_remove_group(kobj: &sensor_inst->pdev->dev.kobj, |
634 | grp: &sensor_inst->fields[i]. |
635 | hid_custom_attribute_group); |
636 | |
637 | kfree(objp: sensor_inst->fields); |
638 | } |
639 | |
640 | static ssize_t hid_sensor_custom_read(struct file *file, char __user *buf, |
641 | size_t count, loff_t *f_ps) |
642 | { |
643 | struct hid_sensor_custom *sensor_inst; |
644 | unsigned int copied; |
645 | int ret; |
646 | |
647 | sensor_inst = container_of(file->private_data, |
648 | struct hid_sensor_custom, custom_dev); |
649 | |
650 | if (count < sizeof(struct hid_sensor_sample)) |
651 | return -EINVAL; |
652 | |
653 | do { |
654 | if (kfifo_is_empty(&sensor_inst->data_fifo)) { |
655 | if (file->f_flags & O_NONBLOCK) |
656 | return -EAGAIN; |
657 | |
658 | ret = wait_event_interruptible(sensor_inst->wait, |
659 | !kfifo_is_empty(&sensor_inst->data_fifo)); |
660 | if (ret) |
661 | return ret; |
662 | } |
663 | ret = kfifo_to_user(&sensor_inst->data_fifo, buf, count, |
664 | &copied); |
665 | if (ret) |
666 | return ret; |
667 | |
668 | } while (copied == 0); |
669 | |
670 | return copied; |
671 | } |
672 | |
673 | static int hid_sensor_custom_release(struct inode *inode, struct file *file) |
674 | { |
675 | struct hid_sensor_custom *sensor_inst; |
676 | |
677 | sensor_inst = container_of(file->private_data, |
678 | struct hid_sensor_custom, custom_dev); |
679 | |
680 | clear_bit(nr: 0, addr: &sensor_inst->misc_opened); |
681 | |
682 | return 0; |
683 | } |
684 | |
685 | static int hid_sensor_custom_open(struct inode *inode, struct file *file) |
686 | { |
687 | struct hid_sensor_custom *sensor_inst; |
688 | |
689 | sensor_inst = container_of(file->private_data, |
690 | struct hid_sensor_custom, custom_dev); |
691 | /* We essentially have single reader and writer */ |
692 | if (test_and_set_bit(nr: 0, addr: &sensor_inst->misc_opened)) |
693 | return -EBUSY; |
694 | |
695 | return stream_open(inode, filp: file); |
696 | } |
697 | |
698 | static __poll_t hid_sensor_custom_poll(struct file *file, |
699 | struct poll_table_struct *wait) |
700 | { |
701 | struct hid_sensor_custom *sensor_inst; |
702 | __poll_t mask = 0; |
703 | |
704 | sensor_inst = container_of(file->private_data, |
705 | struct hid_sensor_custom, custom_dev); |
706 | |
707 | poll_wait(filp: file, wait_address: &sensor_inst->wait, p: wait); |
708 | |
709 | if (!kfifo_is_empty(&sensor_inst->data_fifo)) |
710 | mask = EPOLLIN | EPOLLRDNORM; |
711 | |
712 | return mask; |
713 | } |
714 | |
715 | static const struct file_operations hid_sensor_custom_fops = { |
716 | .open = hid_sensor_custom_open, |
717 | .read = hid_sensor_custom_read, |
718 | .release = hid_sensor_custom_release, |
719 | .poll = hid_sensor_custom_poll, |
720 | .llseek = noop_llseek, |
721 | }; |
722 | |
723 | static int hid_sensor_custom_dev_if_add(struct hid_sensor_custom *sensor_inst) |
724 | { |
725 | int ret; |
726 | |
727 | ret = kfifo_alloc(&sensor_inst->data_fifo, HID_CUSTOM_FIFO_SIZE, |
728 | GFP_KERNEL); |
729 | if (ret) |
730 | return ret; |
731 | |
732 | init_waitqueue_head(&sensor_inst->wait); |
733 | |
734 | sensor_inst->custom_dev.minor = MISC_DYNAMIC_MINOR; |
735 | sensor_inst->custom_dev.name = dev_name(dev: &sensor_inst->pdev->dev); |
736 | sensor_inst->custom_dev.fops = &hid_sensor_custom_fops, |
737 | ret = misc_register(misc: &sensor_inst->custom_dev); |
738 | if (ret) { |
739 | kfifo_free(&sensor_inst->data_fifo); |
740 | return ret; |
741 | } |
742 | return 0; |
743 | } |
744 | |
745 | static void hid_sensor_custom_dev_if_remove(struct hid_sensor_custom |
746 | *sensor_inst) |
747 | { |
748 | wake_up(&sensor_inst->wait); |
749 | misc_deregister(misc: &sensor_inst->custom_dev); |
750 | kfifo_free(&sensor_inst->data_fifo); |
751 | |
752 | } |
753 | |
754 | /* |
755 | * Match a known custom sensor. |
756 | * tag and luid is mandatory. |
757 | */ |
758 | struct hid_sensor_custom_match { |
759 | const char *tag; |
760 | const char *luid; |
761 | const char *model; |
762 | const char *manufacturer; |
763 | bool check_dmi; |
764 | struct dmi_system_id dmi; |
765 | }; |
766 | |
767 | /* |
768 | * Custom sensor properties used for matching. |
769 | */ |
770 | struct hid_sensor_custom_properties { |
771 | u16 serial_num[HID_CUSTOM_MAX_FEATURE_BYTES]; |
772 | u16 model[HID_CUSTOM_MAX_FEATURE_BYTES]; |
773 | u16 manufacturer[HID_CUSTOM_MAX_FEATURE_BYTES]; |
774 | }; |
775 | |
776 | static const struct hid_sensor_custom_match hid_sensor_custom_known_table[] = { |
777 | /* |
778 | * Intel Integrated Sensor Hub (ISH) |
779 | */ |
780 | { /* Intel ISH hinge */ |
781 | .tag = "INT" , |
782 | .luid = "020B000000000000" , |
783 | .manufacturer = "INTEL" , |
784 | }, |
785 | /* |
786 | * Lenovo Intelligent Sensing Solution (LISS) |
787 | */ |
788 | { /* ambient light */ |
789 | .tag = "LISS" , |
790 | .luid = "0041010200000082" , |
791 | .model = "STK3X3X Sensor" , |
792 | .manufacturer = "Vendor 258" , |
793 | .check_dmi = true, |
794 | .dmi.matches = { |
795 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO" ), |
796 | } |
797 | }, |
798 | { /* human presence */ |
799 | .tag = "LISS" , |
800 | .luid = "0226000171AC0081" , |
801 | .model = "VL53L1_HOD Sensor" , |
802 | .manufacturer = "ST_MICRO" , |
803 | .check_dmi = true, |
804 | .dmi.matches = { |
805 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO" ), |
806 | } |
807 | }, |
808 | {} |
809 | }; |
810 | |
811 | static bool hid_sensor_custom_prop_match_str(const u16 *prop, const char *match, |
812 | size_t count) |
813 | { |
814 | while (count-- && *prop && *match) { |
815 | if (*prop != (u16) *match) |
816 | return false; |
817 | prop++; |
818 | match++; |
819 | } |
820 | |
821 | return (count == -1) || *prop == (u16)*match; |
822 | } |
823 | |
824 | static int hid_sensor_custom_get_prop(struct hid_sensor_hub_device *hsdev, |
825 | u32 prop_usage_id, size_t prop_size, |
826 | u16 *prop) |
827 | { |
828 | struct hid_sensor_hub_attribute_info prop_attr = { 0 }; |
829 | int ret; |
830 | |
831 | memset(prop, 0, prop_size); |
832 | |
833 | ret = sensor_hub_input_get_attribute_info(hsdev, type: HID_FEATURE_REPORT, |
834 | usage_id: hsdev->usage, attr_usage_id: prop_usage_id, |
835 | info: &prop_attr); |
836 | if (ret < 0) |
837 | return ret; |
838 | |
839 | ret = sensor_hub_get_feature(hsdev, report_id: prop_attr.report_id, |
840 | field_index: prop_attr.index, buffer_size: prop_size, buffer: prop); |
841 | if (ret < 0) { |
842 | hid_err(hsdev->hdev, "Failed to get sensor property %08x %d\n" , |
843 | prop_usage_id, ret); |
844 | return ret; |
845 | } |
846 | |
847 | return 0; |
848 | } |
849 | |
850 | static bool |
851 | hid_sensor_custom_do_match(struct hid_sensor_hub_device *hsdev, |
852 | const struct hid_sensor_custom_match *match, |
853 | const struct hid_sensor_custom_properties *prop) |
854 | { |
855 | struct dmi_system_id dmi[] = { match->dmi, { 0 } }; |
856 | |
857 | if (!hid_sensor_custom_prop_match_str(prop: prop->serial_num, match: "LUID:" , count: 5) || |
858 | !hid_sensor_custom_prop_match_str(prop: prop->serial_num + 5, match: match->luid, |
859 | HID_CUSTOM_MAX_FEATURE_BYTES - 5)) |
860 | return false; |
861 | |
862 | if (match->model && |
863 | !hid_sensor_custom_prop_match_str(prop: prop->model, match: match->model, |
864 | HID_CUSTOM_MAX_FEATURE_BYTES)) |
865 | return false; |
866 | |
867 | if (match->manufacturer && |
868 | !hid_sensor_custom_prop_match_str(prop: prop->manufacturer, match: match->manufacturer, |
869 | HID_CUSTOM_MAX_FEATURE_BYTES)) |
870 | return false; |
871 | |
872 | if (match->check_dmi && !dmi_check_system(list: dmi)) |
873 | return false; |
874 | |
875 | return true; |
876 | } |
877 | |
878 | static int |
879 | hid_sensor_custom_properties_get(struct hid_sensor_hub_device *hsdev, |
880 | struct hid_sensor_custom_properties *prop) |
881 | { |
882 | int ret; |
883 | |
884 | ret = hid_sensor_custom_get_prop(hsdev, |
885 | HID_USAGE_SENSOR_PROP_SERIAL_NUM, |
886 | HID_CUSTOM_MAX_FEATURE_BYTES, |
887 | prop: prop->serial_num); |
888 | if (ret < 0) |
889 | return ret; |
890 | |
891 | /* |
892 | * Ignore errors on the following model and manufacturer properties. |
893 | * Because these are optional, it is not an error if they are missing. |
894 | */ |
895 | |
896 | hid_sensor_custom_get_prop(hsdev, HID_USAGE_SENSOR_PROP_MODEL, |
897 | HID_CUSTOM_MAX_FEATURE_BYTES, |
898 | prop: prop->model); |
899 | |
900 | hid_sensor_custom_get_prop(hsdev, HID_USAGE_SENSOR_PROP_MANUFACTURER, |
901 | HID_CUSTOM_MAX_FEATURE_BYTES, |
902 | prop: prop->manufacturer); |
903 | |
904 | return 0; |
905 | } |
906 | |
907 | static int |
908 | hid_sensor_custom_get_known(struct hid_sensor_hub_device *hsdev, |
909 | const struct hid_sensor_custom_match **known) |
910 | { |
911 | int ret; |
912 | const struct hid_sensor_custom_match *match = |
913 | hid_sensor_custom_known_table; |
914 | struct hid_sensor_custom_properties *prop; |
915 | |
916 | prop = kmalloc(size: sizeof(struct hid_sensor_custom_properties), GFP_KERNEL); |
917 | if (!prop) |
918 | return -ENOMEM; |
919 | |
920 | ret = hid_sensor_custom_properties_get(hsdev, prop); |
921 | if (ret < 0) |
922 | goto out; |
923 | |
924 | while (match->tag) { |
925 | if (hid_sensor_custom_do_match(hsdev, match, prop)) { |
926 | *known = match; |
927 | ret = 0; |
928 | goto out; |
929 | } |
930 | match++; |
931 | } |
932 | ret = -ENODATA; |
933 | out: |
934 | kfree(objp: prop); |
935 | return ret; |
936 | } |
937 | |
938 | static struct platform_device * |
939 | hid_sensor_register_platform_device(struct platform_device *pdev, |
940 | struct hid_sensor_hub_device *hsdev, |
941 | const struct hid_sensor_custom_match *match) |
942 | { |
943 | char real_usage[HID_SENSOR_USAGE_LENGTH] = { 0 }; |
944 | struct platform_device *custom_pdev; |
945 | const char *dev_name; |
946 | char *c; |
947 | |
948 | memcpy(real_usage, match->luid, 4); |
949 | |
950 | /* usage id are all lowcase */ |
951 | for (c = real_usage; *c != '\0'; c++) |
952 | *c = tolower(*c); |
953 | |
954 | /* HID-SENSOR-TAG-REAL_USAGE_ID */ |
955 | dev_name = kasprintf(GFP_KERNEL, fmt: "HID-SENSOR-%s-%s" , |
956 | match->tag, real_usage); |
957 | if (!dev_name) |
958 | return ERR_PTR(error: -ENOMEM); |
959 | |
960 | custom_pdev = platform_device_register_data(parent: pdev->dev.parent, name: dev_name, |
961 | PLATFORM_DEVID_AUTO, data: hsdev, |
962 | size: sizeof(*hsdev)); |
963 | kfree(objp: dev_name); |
964 | return custom_pdev; |
965 | } |
966 | |
967 | static int hid_sensor_custom_probe(struct platform_device *pdev) |
968 | { |
969 | struct hid_sensor_custom *sensor_inst; |
970 | struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; |
971 | int ret; |
972 | const struct hid_sensor_custom_match *match; |
973 | |
974 | sensor_inst = devm_kzalloc(dev: &pdev->dev, size: sizeof(*sensor_inst), |
975 | GFP_KERNEL); |
976 | if (!sensor_inst) |
977 | return -ENOMEM; |
978 | |
979 | sensor_inst->callbacks.capture_sample = hid_sensor_capture_sample; |
980 | sensor_inst->callbacks.send_event = hid_sensor_send_event; |
981 | sensor_inst->callbacks.pdev = pdev; |
982 | sensor_inst->hsdev = hsdev; |
983 | sensor_inst->pdev = pdev; |
984 | mutex_init(&sensor_inst->mutex); |
985 | platform_set_drvdata(pdev, data: sensor_inst); |
986 | |
987 | ret = hid_sensor_custom_get_known(hsdev, known: &match); |
988 | if (!ret) { |
989 | sensor_inst->custom_pdev = |
990 | hid_sensor_register_platform_device(pdev, hsdev, match); |
991 | |
992 | ret = PTR_ERR_OR_ZERO(ptr: sensor_inst->custom_pdev); |
993 | if (ret) { |
994 | dev_err(&pdev->dev, |
995 | "register_platform_device failed\n" ); |
996 | return ret; |
997 | } |
998 | |
999 | return 0; |
1000 | } |
1001 | |
1002 | ret = sensor_hub_register_callback(hsdev, usage_id: hsdev->usage, |
1003 | usage_callback: &sensor_inst->callbacks); |
1004 | if (ret < 0) { |
1005 | dev_err(&pdev->dev, "callback reg failed\n" ); |
1006 | return ret; |
1007 | } |
1008 | |
1009 | ret = sysfs_create_group(kobj: &sensor_inst->pdev->dev.kobj, |
1010 | grp: &enable_sensor_attr_group); |
1011 | if (ret) |
1012 | goto err_remove_callback; |
1013 | |
1014 | ret = hid_sensor_custom_add_attributes(sensor_inst); |
1015 | if (ret) |
1016 | goto err_remove_group; |
1017 | |
1018 | ret = hid_sensor_custom_dev_if_add(sensor_inst); |
1019 | if (ret) |
1020 | goto err_remove_attributes; |
1021 | |
1022 | return 0; |
1023 | |
1024 | err_remove_attributes: |
1025 | hid_sensor_custom_remove_attributes(sensor_inst); |
1026 | err_remove_group: |
1027 | sysfs_remove_group(kobj: &sensor_inst->pdev->dev.kobj, |
1028 | grp: &enable_sensor_attr_group); |
1029 | err_remove_callback: |
1030 | sensor_hub_remove_callback(hsdev, usage_id: hsdev->usage); |
1031 | |
1032 | return ret; |
1033 | } |
1034 | |
1035 | static int hid_sensor_custom_remove(struct platform_device *pdev) |
1036 | { |
1037 | struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev); |
1038 | struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data; |
1039 | |
1040 | if (sensor_inst->custom_pdev) { |
1041 | platform_device_unregister(sensor_inst->custom_pdev); |
1042 | return 0; |
1043 | } |
1044 | |
1045 | hid_sensor_custom_dev_if_remove(sensor_inst); |
1046 | hid_sensor_custom_remove_attributes(sensor_inst); |
1047 | sysfs_remove_group(kobj: &sensor_inst->pdev->dev.kobj, |
1048 | grp: &enable_sensor_attr_group); |
1049 | sensor_hub_remove_callback(hsdev, usage_id: hsdev->usage); |
1050 | |
1051 | return 0; |
1052 | } |
1053 | |
1054 | static const struct platform_device_id hid_sensor_custom_ids[] = { |
1055 | { |
1056 | .name = "HID-SENSOR-2000e1" , |
1057 | }, |
1058 | { |
1059 | .name = "HID-SENSOR-2000e2" , |
1060 | }, |
1061 | { /* sentinel */ } |
1062 | }; |
1063 | MODULE_DEVICE_TABLE(platform, hid_sensor_custom_ids); |
1064 | |
1065 | static struct platform_driver hid_sensor_custom_platform_driver = { |
1066 | .id_table = hid_sensor_custom_ids, |
1067 | .driver = { |
1068 | .name = KBUILD_MODNAME, |
1069 | }, |
1070 | .probe = hid_sensor_custom_probe, |
1071 | .remove = hid_sensor_custom_remove, |
1072 | }; |
1073 | module_platform_driver(hid_sensor_custom_platform_driver); |
1074 | |
1075 | MODULE_DESCRIPTION("HID Sensor Custom and Generic sensor Driver" ); |
1076 | MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>" ); |
1077 | MODULE_LICENSE("GPL" ); |
1078 | |