Commit | Line | Data |
---|---|---|
2025cf9e | 1 | // SPDX-License-Identifier: GPL-2.0-only |
4a7de051 SP |
2 | /* |
3 | * hid-sensor-custom.c | |
4 | * Copyright (c) 2015, Intel Corporation. | |
4a7de051 SP |
5 | */ |
6 | ||
23931967 | 7 | #include <linux/ctype.h> |
98c062e8 | 8 | #include <linux/dmi.h> |
4a7de051 SP |
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 | |
23931967 | 26 | #define HID_SENSOR_USAGE_LENGTH (4 + 1) |
4a7de051 SP |
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; | |
23931967 | 56 | struct platform_device *custom_pdev; |
4a7de051 SP |
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 | ||
9d013910 | 66 | static struct attribute hid_custom_attrs[HID_CUSTOM_TOTAL_ATTRS] = { |
4a7de051 SP |
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 | { | |
77f9f772 | 156 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
4a7de051 SP |
157 | |
158 | return sprintf(buf, "%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(sensor_inst->hsdev, | |
189 | sensor_inst->power_state->attribute.report_id, | |
190 | sensor_inst->power_state->attribute.index, | |
191 | power_state_usage_id); | |
192 | if (sensor_inst->report_state) | |
193 | report_val = hid_sensor_get_usage_index(sensor_inst->hsdev, | |
194 | sensor_inst->report_state->attribute.report_id, | |
195 | sensor_inst->report_state->attribute.index, | |
196 | 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(sensor_inst->hsdev, | |
202 | sensor_inst->power_state->attribute.report_id, | |
203 | sensor_inst->power_state->attribute.index, | |
204 | sizeof(power_val), | |
205 | &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(sensor_inst->hsdev, | |
217 | sensor_inst->report_state->attribute.report_id, | |
218 | sensor_inst->report_state->attribute.index, | |
219 | sizeof(report_val), | |
220 | &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 | { | |
77f9f772 | 235 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
4a7de051 SP |
236 | int value; |
237 | int ret = -EINVAL; | |
238 | ||
239 | if (kstrtoint(buf, 0, &value) != 0) | |
240 | return -EINVAL; | |
241 | ||
242 | mutex_lock(&sensor_inst->mutex); | |
243 | if (value && !sensor_inst->enable) { | |
244 | ret = sensor_hub_device_open(sensor_inst->hsdev); | |
245 | if (ret) | |
246 | goto unlock_state; | |
247 | ||
248 | ret = set_power_report_state(sensor_inst, true); | |
249 | if (ret) { | |
250 | sensor_hub_device_close(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, false); | |
256 | sensor_hub_device_close(sensor_inst->hsdev); | |
257 | sensor_inst->enable = false; | |
258 | } | |
259 | unlock_state: | |
260 | mutex_unlock(&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 | ||
58ee3e08 | 273 | static const struct attribute_group enable_sensor_attr_group = { |
4a7de051 SP |
274 | .attrs = enable_sensor_attrs, |
275 | }; | |
276 | ||
277 | static ssize_t show_value(struct device *dev, struct device_attribute *attr, | |
278 | char *buf) | |
279 | { | |
77f9f772 | 280 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
4a7de051 SP |
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 | ||
4c4480aa | 288 | if (sscanf(attr->attr.name, "feature-%x-%x-%s", &index, &usage, |
4a7de051 SP |
289 | name) == 3) { |
290 | feature = true; | |
291 | field_index = index + sensor_inst->input_field_count; | |
4c4480aa | 292 | } else if (sscanf(attr->attr.name, "input-%x-%x-%s", &index, &usage, |
4a7de051 SP |
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(sensor_inst->hsdev, | |
312 | report_id, | |
313 | index, | |
314 | sizeof(values), values); | |
315 | if (ret < 0) | |
316 | return ret; | |
317 | ||
318 | while (i < ret) { | |
319 | if (i + attribute->size > ret) { | |
62a1a580 | 320 | len += scnprintf(&buf[len], |
4a7de051 SP |
321 | PAGE_SIZE - len, |
322 | "%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 | } | |
62a1a580 | 343 | len += scnprintf(&buf[len], PAGE_SIZE - len, |
4a7de051 SP |
344 | "%lld ", value); |
345 | } | |
62a1a580 | 346 | len += scnprintf(&buf[len], PAGE_SIZE - len, "\n"); |
4a7de051 SP |
347 | |
348 | return len; | |
349 | } else if (input) | |
350 | value = sensor_hub_input_attr_get_raw_value( | |
351 | sensor_inst->hsdev, | |
352 | sensor_inst->hsdev->usage, | |
353 | usage, report_id, | |
0145b505 | 354 | SENSOR_HUB_SYNC, false); |
4a7de051 SP |
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(&usage, hid_custom_usage_desc_table, | |
371 | ARRAY_SIZE(hid_custom_usage_desc_table), | |
372 | sizeof(struct hid_custom_usage_desc), | |
373 | usage_id_cmp); | |
374 | if (usage_desc) | |
375 | return snprintf(buf, PAGE_SIZE, "%s\n", | |
376 | usage_desc->desc); | |
377 | else | |
378 | return sprintf(buf, "not-specified\n"); | |
379 | } else | |
380 | return -EINVAL; | |
381 | ||
382 | return sprintf(buf, "%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 | { | |
77f9f772 | 388 | struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev); |
4a7de051 SP |
389 | int index, field_index, usage; |
390 | char name[HID_CUSTOM_NAME_LENGTH]; | |
3202f482 | 391 | int value, ret; |
4a7de051 | 392 | |
4c4480aa | 393 | if (sscanf(attr->attr.name, "feature-%x-%x-%s", &index, &usage, |
4a7de051 SP |
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; | |
4a7de051 SP |
401 | |
402 | if (kstrtoint(buf, 0, &value) != 0) | |
403 | return -EINVAL; | |
404 | ||
405 | report_id = sensor_inst->fields[field_index].attribute. | |
406 | report_id; | |
3202f482 SP |
407 | ret = sensor_hub_set_feature(sensor_inst->hsdev, report_id, |
408 | index, sizeof(value), &value); | |
409 | if (ret) | |
410 | return ret; | |
4a7de051 SP |
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(priv); | |
422 | struct hid_sensor_sample header; | |
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(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(sensor_inst->fields, | |
484 | (sensor_inst->sensor_field_count + 1) * | |
485 | sizeof(struct hid_sensor_custom_field), GFP_KERNEL); | |
486 | if (!fields) { | |
487 | kfree(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(sensor_field->group_name, | |
508 | sizeof(sensor_field->group_name), "feature-%x-%x", | |
509 | sensor_field->attribute.index, | |
510 | sensor_field->attribute.attrib_id); | |
511 | else if (report_type == HID_INPUT_REPORT) { | |
512 | snprintf(sensor_field->group_name, | |
513 | sizeof(sensor_field->group_name), | |
514 | "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 | 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 | &hdev->report_enum[j], 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((char *)&sensor_inst->fields[i].attr_name[j], | |
591 | HID_CUSTOM_NAME_LENGTH, "%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(&sensor_inst->pdev->dev.kobj, | |
610 | &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(&sensor_inst->pdev->dev.kobj, | |
634 | &sensor_inst->fields[i]. | |
635 | hid_custom_attribute_group); | |
636 | ||
637 | kfree(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(0, &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(0, &sensor_inst->misc_opened)) | |
693 | return -EBUSY; | |
694 | ||
3975b097 | 695 | return stream_open(inode, file); |
4a7de051 SP |
696 | } |
697 | ||
afc9a42b | 698 | static __poll_t hid_sensor_custom_poll(struct file *file, |
4a7de051 SP |
699 | struct poll_table_struct *wait) |
700 | { | |
701 | struct hid_sensor_custom *sensor_inst; | |
afc9a42b | 702 | __poll_t mask = 0; |
4a7de051 SP |
703 | |
704 | sensor_inst = container_of(file->private_data, | |
705 | struct hid_sensor_custom, custom_dev); | |
706 | ||
707 | poll_wait(file, &sensor_inst->wait, wait); | |
708 | ||
709 | if (!kfifo_is_empty(&sensor_inst->data_fifo)) | |
a9a08845 | 710 | mask = EPOLLIN | EPOLLRDNORM; |
4a7de051 SP |
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(&sensor_inst->pdev->dev); | |
736 | sensor_inst->custom_dev.fops = &hid_sensor_custom_fops, | |
737 | ret = misc_register(&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(&sensor_inst->custom_dev); | |
750 | kfifo_free(&sensor_inst->data_fifo); | |
751 | ||
752 | } | |
753 | ||
98c062e8 PJ |
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 | }; | |
23931967 | 766 | |
98c062e8 PJ |
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 | }, | |
48c79bb0 PJ |
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 | }, | |
98c062e8 PJ |
808 | {} |
809 | }; | |
23931967 | 810 | |
98c062e8 PJ |
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++; | |
23931967 YX |
819 | } |
820 | ||
98c062e8 | 821 | return (count == -1) || *prop == (u16)*match; |
23931967 YX |
822 | } |
823 | ||
98c062e8 PJ |
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) | |
23931967 | 827 | { |
98c062e8 | 828 | struct hid_sensor_hub_attribute_info prop_attr = { 0 }; |
23931967 | 829 | int ret; |
23931967 | 830 | |
98c062e8 | 831 | memset(prop, 0, prop_size); |
23931967 | 832 | |
98c062e8 PJ |
833 | ret = sensor_hub_input_get_attribute_info(hsdev, HID_FEATURE_REPORT, |
834 | hsdev->usage, prop_usage_id, | |
835 | &prop_attr); | |
23931967 YX |
836 | if (ret < 0) |
837 | return ret; | |
838 | ||
98c062e8 PJ |
839 | ret = sensor_hub_get_feature(hsdev, prop_attr.report_id, |
840 | prop_attr.index, prop_size, 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; | |
23931967 YX |
845 | } |
846 | ||
98c062e8 PJ |
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->serial_num, "LUID:", 5) || | |
858 | !hid_sensor_custom_prop_match_str(prop->serial_num + 5, match->luid, | |
859 | HID_CUSTOM_MAX_FEATURE_BYTES - 5)) | |
860 | return false; | |
23931967 | 861 | |
98c062e8 PJ |
862 | if (match->model && |
863 | !hid_sensor_custom_prop_match_str(prop->model, match->model, | |
864 | HID_CUSTOM_MAX_FEATURE_BYTES)) | |
865 | return false; | |
23931967 | 866 | |
98c062e8 PJ |
867 | if (match->manufacturer && |
868 | !hid_sensor_custom_prop_match_str(prop->manufacturer, match->manufacturer, | |
869 | HID_CUSTOM_MAX_FEATURE_BYTES)) | |
870 | return false; | |
23931967 | 871 | |
98c062e8 PJ |
872 | if (match->check_dmi && !dmi_check_system(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->serial_num); | |
23931967 YX |
888 | if (ret < 0) |
889 | return ret; | |
890 | ||
98c062e8 PJ |
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->model); | |
23931967 | 899 | |
98c062e8 PJ |
900 | hid_sensor_custom_get_prop(hsdev, HID_USAGE_SENSOR_PROP_MANUFACTURER, |
901 | HID_CUSTOM_MAX_FEATURE_BYTES, | |
902 | prop->manufacturer); | |
23931967 | 903 | |
98c062e8 PJ |
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; | |
f1f73651 | 914 | struct hid_sensor_custom_properties *prop; |
98c062e8 | 915 | |
f1f73651 JK |
916 | prop = kmalloc(sizeof(struct hid_sensor_custom_properties), GFP_KERNEL); |
917 | if (!prop) | |
918 | return -ENOMEM; | |
919 | ||
920 | ret = hid_sensor_custom_properties_get(hsdev, prop); | |
98c062e8 | 921 | if (ret < 0) |
f1f73651 | 922 | goto out; |
98c062e8 PJ |
923 | |
924 | while (match->tag) { | |
f1f73651 | 925 | if (hid_sensor_custom_do_match(hsdev, match, prop)) { |
98c062e8 | 926 | *known = match; |
f1f73651 JK |
927 | ret = 0; |
928 | goto out; | |
98c062e8 PJ |
929 | } |
930 | match++; | |
23931967 | 931 | } |
f1f73651 JK |
932 | ret = -ENODATA; |
933 | out: | |
934 | kfree(prop); | |
935 | return ret; | |
23931967 YX |
936 | } |
937 | ||
938 | static struct platform_device * | |
939 | hid_sensor_register_platform_device(struct platform_device *pdev, | |
940 | struct hid_sensor_hub_device *hsdev, | |
98c062e8 | 941 | const struct hid_sensor_custom_match *match) |
23931967 | 942 | { |
7c3650a8 | 943 | char real_usage[HID_SENSOR_USAGE_LENGTH] = { 0 }; |
23931967 YX |
944 | struct platform_device *custom_pdev; |
945 | const char *dev_name; | |
946 | char *c; | |
947 | ||
98c062e8 | 948 | memcpy(real_usage, match->luid, 4); |
23931967 YX |
949 | |
950 | /* usage id are all lowcase */ | |
951 | for (c = real_usage; *c != '\0'; c++) | |
952 | *c = tolower(*c); | |
953 | ||
98c062e8 PJ |
954 | /* HID-SENSOR-TAG-REAL_USAGE_ID */ |
955 | dev_name = kasprintf(GFP_KERNEL, "HID-SENSOR-%s-%s", | |
956 | match->tag, real_usage); | |
23931967 YX |
957 | if (!dev_name) |
958 | return ERR_PTR(-ENOMEM); | |
959 | ||
960 | custom_pdev = platform_device_register_data(pdev->dev.parent, dev_name, | |
9861a25f | 961 | PLATFORM_DEVID_AUTO, hsdev, |
23931967 YX |
962 | sizeof(*hsdev)); |
963 | kfree(dev_name); | |
964 | return custom_pdev; | |
965 | } | |
966 | ||
4a7de051 SP |
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; | |
98c062e8 | 972 | const struct hid_sensor_custom_match *match; |
4a7de051 SP |
973 | |
974 | sensor_inst = devm_kzalloc(&pdev->dev, 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, sensor_inst); | |
23931967 | 986 | |
98c062e8 PJ |
987 | ret = hid_sensor_custom_get_known(hsdev, &match); |
988 | if (!ret) { | |
23931967 | 989 | sensor_inst->custom_pdev = |
98c062e8 | 990 | hid_sensor_register_platform_device(pdev, hsdev, match); |
23931967 YX |
991 | |
992 | ret = PTR_ERR_OR_ZERO(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 | ||
4a7de051 SP |
1002 | ret = sensor_hub_register_callback(hsdev, hsdev->usage, |
1003 | &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(&sensor_inst->pdev->dev.kobj, | |
1010 | &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(&sensor_inst->pdev->dev.kobj, | |
1028 | &enable_sensor_attr_group); | |
1029 | err_remove_callback: | |
1030 | sensor_hub_remove_callback(hsdev, 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 | ||
23931967 YX |
1040 | if (sensor_inst->custom_pdev) { |
1041 | platform_device_unregister(sensor_inst->custom_pdev); | |
1042 | return 0; | |
1043 | } | |
1044 | ||
4a7de051 SP |
1045 | hid_sensor_custom_dev_if_remove(sensor_inst); |
1046 | hid_sensor_custom_remove_attributes(sensor_inst); | |
1047 | sysfs_remove_group(&sensor_inst->pdev->dev.kobj, | |
1048 | &enable_sensor_attr_group); | |
1049 | sensor_hub_remove_callback(hsdev, hsdev->usage); | |
1050 | ||
1051 | return 0; | |
1052 | } | |
1053 | ||
0be2bfdc | 1054 | static const struct platform_device_id hid_sensor_custom_ids[] = { |
4a7de051 SP |
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"); |