1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * HID Sensors Driver
4 * Copyright (c) 2012, Intel Corporation.
5 */
6 #include <linux/bitops.h>
7 #include <linux/device.h>
8 #include <linux/platform_device.h>
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/hid-sensor-hub.h>
12 #include <linux/iio/iio.h>
13 #include <linux/iio/buffer.h>
14 #include "../common/hid-sensors/hid-sensor-trigger.h"
15
16 enum {
17 CHANNEL_SCAN_INDEX_INTENSITY,
18 CHANNEL_SCAN_INDEX_ILLUM,
19 CHANNEL_SCAN_INDEX_COLOR_TEMP,
20 CHANNEL_SCAN_INDEX_CHROMATICITY_X,
21 CHANNEL_SCAN_INDEX_CHROMATICITY_Y,
22 CHANNEL_SCAN_INDEX_MAX
23 };
24
25 #define CHANNEL_SCAN_INDEX_TIMESTAMP CHANNEL_SCAN_INDEX_MAX
26
27 struct als_state {
28 struct hid_sensor_hub_callbacks callbacks;
29 struct hid_sensor_common common_attributes;
30 struct hid_sensor_hub_attribute_info als[CHANNEL_SCAN_INDEX_MAX];
31 struct iio_chan_spec channels[CHANNEL_SCAN_INDEX_MAX + 1];
32 struct {
33 u32 illum[CHANNEL_SCAN_INDEX_MAX];
34 aligned_s64 timestamp;
35 } scan;
36 int scale_pre_decml[CHANNEL_SCAN_INDEX_MAX];
37 int scale_post_decml[CHANNEL_SCAN_INDEX_MAX];
38 int scale_precision[CHANNEL_SCAN_INDEX_MAX];
39 int value_offset;
40 int num_channels;
41 s64 timestamp;
42 unsigned long als_scan_mask[2];
43 };
44
45 /* The order of usage ids must match scan index starting from CHANNEL_SCAN_INDEX_INTENSITY */
46 static const u32 als_usage_ids[] = {
47 HID_USAGE_SENSOR_LIGHT_ILLUM,
48 HID_USAGE_SENSOR_LIGHT_ILLUM,
49 HID_USAGE_SENSOR_LIGHT_COLOR_TEMPERATURE,
50 HID_USAGE_SENSOR_LIGHT_CHROMATICITY_X,
51 HID_USAGE_SENSOR_LIGHT_CHROMATICITY_Y,
52 };
53
54 static const u32 als_sensitivity_addresses[] = {
55 HID_USAGE_SENSOR_DATA_LIGHT,
56 HID_USAGE_SENSOR_LIGHT_ILLUM,
57 };
58
59 /* Channel definitions */
60 static const struct iio_chan_spec als_channels[] = {
61 {
62 .type = IIO_INTENSITY,
63 .modified = 1,
64 .channel2 = IIO_MOD_LIGHT_BOTH,
65 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
66 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
67 BIT(IIO_CHAN_INFO_SCALE) |
68 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
69 BIT(IIO_CHAN_INFO_HYSTERESIS) |
70 BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
71 .scan_index = CHANNEL_SCAN_INDEX_INTENSITY,
72 },
73 {
74 .type = IIO_LIGHT,
75 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
76 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
77 BIT(IIO_CHAN_INFO_SCALE) |
78 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
79 BIT(IIO_CHAN_INFO_HYSTERESIS) |
80 BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
81 .scan_index = CHANNEL_SCAN_INDEX_ILLUM,
82 },
83 {
84 .type = IIO_COLORTEMP,
85 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
86 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
87 BIT(IIO_CHAN_INFO_SCALE) |
88 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
89 BIT(IIO_CHAN_INFO_HYSTERESIS) |
90 BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
91 .scan_index = CHANNEL_SCAN_INDEX_COLOR_TEMP,
92 },
93 {
94 .type = IIO_CHROMATICITY,
95 .modified = 1,
96 .channel2 = IIO_MOD_X,
97 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
98 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
99 BIT(IIO_CHAN_INFO_SCALE) |
100 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
101 BIT(IIO_CHAN_INFO_HYSTERESIS) |
102 BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
103 .scan_index = CHANNEL_SCAN_INDEX_CHROMATICITY_X,
104 },
105 {
106 .type = IIO_CHROMATICITY,
107 .modified = 1,
108 .channel2 = IIO_MOD_Y,
109 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
110 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
111 BIT(IIO_CHAN_INFO_SCALE) |
112 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
113 BIT(IIO_CHAN_INFO_HYSTERESIS) |
114 BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
115 .scan_index = CHANNEL_SCAN_INDEX_CHROMATICITY_Y,
116 },
117 IIO_CHAN_SOFT_TIMESTAMP(CHANNEL_SCAN_INDEX_TIMESTAMP)
118 };
119
120 /* Channel read_raw handler */
als_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)121 static int als_read_raw(struct iio_dev *indio_dev,
122 struct iio_chan_spec const *chan,
123 int *val, int *val2, long mask)
124 {
125 struct als_state *als_state = iio_priv(indio_dev);
126 struct hid_sensor_hub_device *hsdev = als_state->common_attributes.hsdev;
127 int report_id = -1;
128 u32 address;
129 int ret_type;
130 s32 min;
131
132 *val = 0;
133 *val2 = 0;
134 switch (mask) {
135 case IIO_CHAN_INFO_RAW:
136 switch (chan->scan_index) {
137 case CHANNEL_SCAN_INDEX_INTENSITY:
138 case CHANNEL_SCAN_INDEX_ILLUM:
139 report_id = als_state->als[chan->scan_index].report_id;
140 min = als_state->als[chan->scan_index].logical_minimum;
141 address = HID_USAGE_SENSOR_LIGHT_ILLUM;
142 break;
143 case CHANNEL_SCAN_INDEX_COLOR_TEMP:
144 report_id = als_state->als[chan->scan_index].report_id;
145 min = als_state->als[chan->scan_index].logical_minimum;
146 address = HID_USAGE_SENSOR_LIGHT_COLOR_TEMPERATURE;
147 break;
148 case CHANNEL_SCAN_INDEX_CHROMATICITY_X:
149 report_id = als_state->als[chan->scan_index].report_id;
150 min = als_state->als[chan->scan_index].logical_minimum;
151 address = HID_USAGE_SENSOR_LIGHT_CHROMATICITY_X;
152 break;
153 case CHANNEL_SCAN_INDEX_CHROMATICITY_Y:
154 report_id = als_state->als[chan->scan_index].report_id;
155 min = als_state->als[chan->scan_index].logical_minimum;
156 address = HID_USAGE_SENSOR_LIGHT_CHROMATICITY_Y;
157 break;
158 default:
159 report_id = -1;
160 break;
161 }
162 if (report_id >= 0) {
163 hid_sensor_power_state(&als_state->common_attributes,
164 true);
165 *val = sensor_hub_input_attr_get_raw_value(
166 hsdev, hsdev->usage, address, report_id,
167 SENSOR_HUB_SYNC, min < 0);
168 hid_sensor_power_state(&als_state->common_attributes,
169 false);
170 } else {
171 *val = 0;
172 return -EINVAL;
173 }
174 ret_type = IIO_VAL_INT;
175 break;
176 case IIO_CHAN_INFO_SCALE:
177 if (chan->scan_index >= CHANNEL_SCAN_INDEX_MAX)
178 return -EINVAL;
179 *val = als_state->scale_pre_decml[chan->scan_index];
180 *val2 = als_state->scale_post_decml[chan->scan_index];
181 ret_type = als_state->scale_precision[chan->scan_index];
182 break;
183 case IIO_CHAN_INFO_OFFSET:
184 *val = als_state->value_offset;
185 ret_type = IIO_VAL_INT;
186 break;
187 case IIO_CHAN_INFO_SAMP_FREQ:
188 ret_type = hid_sensor_read_samp_freq_value(
189 &als_state->common_attributes, val, val2);
190 break;
191 case IIO_CHAN_INFO_HYSTERESIS:
192 ret_type = hid_sensor_read_raw_hyst_value(
193 &als_state->common_attributes, val, val2);
194 break;
195 case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
196 ret_type = hid_sensor_read_raw_hyst_rel_value(
197 &als_state->common_attributes, val, val2);
198 break;
199 default:
200 ret_type = -EINVAL;
201 break;
202 }
203
204 return ret_type;
205 }
206
207 /* Channel write_raw handler */
als_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)208 static int als_write_raw(struct iio_dev *indio_dev,
209 struct iio_chan_spec const *chan,
210 int val, int val2, long mask)
211 {
212 struct als_state *als_state = iio_priv(indio_dev);
213 int ret = 0;
214
215 switch (mask) {
216 case IIO_CHAN_INFO_SAMP_FREQ:
217 ret = hid_sensor_write_samp_freq_value(
218 &als_state->common_attributes, val, val2);
219 break;
220 case IIO_CHAN_INFO_HYSTERESIS:
221 ret = hid_sensor_write_raw_hyst_value(
222 &als_state->common_attributes, val, val2);
223 break;
224 case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
225 ret = hid_sensor_write_raw_hyst_rel_value(
226 &als_state->common_attributes, val, val2);
227 break;
228 default:
229 ret = -EINVAL;
230 }
231
232 return ret;
233 }
234
235 static const struct iio_info als_info = {
236 .read_raw = &als_read_raw,
237 .write_raw = &als_write_raw,
238 };
239
240 /* Callback handler to send event after all samples are received and captured */
als_proc_event(struct hid_sensor_hub_device * hsdev,u32 usage_id,void * priv)241 static int als_proc_event(struct hid_sensor_hub_device *hsdev,
242 u32 usage_id, void *priv)
243 {
244 struct iio_dev *indio_dev = platform_get_drvdata(priv);
245 struct als_state *als_state = iio_priv(indio_dev);
246
247 dev_dbg(&indio_dev->dev, "als_proc_event\n");
248 if (atomic_read(&als_state->common_attributes.data_ready)) {
249 if (!als_state->timestamp)
250 als_state->timestamp = iio_get_time_ns(indio_dev);
251
252 iio_push_to_buffers_with_ts(indio_dev, &als_state->scan,
253 sizeof(als_state->scan),
254 als_state->timestamp);
255 als_state->timestamp = 0;
256 }
257
258 return 0;
259 }
260
261 /* Capture samples in local storage */
als_capture_sample(struct hid_sensor_hub_device * hsdev,u32 usage_id,size_t raw_len,char * raw_data,void * priv)262 static int als_capture_sample(struct hid_sensor_hub_device *hsdev,
263 u32 usage_id,
264 size_t raw_len, char *raw_data,
265 void *priv)
266 {
267 struct iio_dev *indio_dev = platform_get_drvdata(priv);
268 struct als_state *als_state = iio_priv(indio_dev);
269 int ret = -EINVAL;
270 u32 sample_data = *(u32 *)raw_data;
271
272 switch (usage_id) {
273 case HID_USAGE_SENSOR_LIGHT_ILLUM:
274 als_state->scan.illum[CHANNEL_SCAN_INDEX_INTENSITY] = sample_data;
275 als_state->scan.illum[CHANNEL_SCAN_INDEX_ILLUM] = sample_data;
276 ret = 0;
277 break;
278 case HID_USAGE_SENSOR_LIGHT_COLOR_TEMPERATURE:
279 als_state->scan.illum[CHANNEL_SCAN_INDEX_COLOR_TEMP] = sample_data;
280 ret = 0;
281 break;
282 case HID_USAGE_SENSOR_LIGHT_CHROMATICITY_X:
283 als_state->scan.illum[CHANNEL_SCAN_INDEX_CHROMATICITY_X] = sample_data;
284 ret = 0;
285 break;
286 case HID_USAGE_SENSOR_LIGHT_CHROMATICITY_Y:
287 als_state->scan.illum[CHANNEL_SCAN_INDEX_CHROMATICITY_Y] = sample_data;
288 ret = 0;
289 break;
290 case HID_USAGE_SENSOR_TIME_TIMESTAMP:
291 als_state->timestamp = hid_sensor_convert_timestamp(&als_state->common_attributes,
292 *(s64 *)raw_data);
293 ret = 0;
294 break;
295 default:
296 break;
297 }
298
299 return ret;
300 }
301
302 /* Parse report which is specific to an usage id*/
als_parse_report(struct platform_device * pdev,struct hid_sensor_hub_device * hsdev,u32 usage_id,struct als_state * st)303 static int als_parse_report(struct platform_device *pdev,
304 struct hid_sensor_hub_device *hsdev,
305 u32 usage_id,
306 struct als_state *st)
307 {
308 struct iio_chan_spec *channels;
309 int ret, index = 0;
310 int i;
311
312 channels = st->channels;
313
314 for (i = 0; i < CHANNEL_SCAN_INDEX_MAX; ++i) {
315 ret = sensor_hub_input_get_attribute_info(hsdev,
316 HID_INPUT_REPORT,
317 usage_id,
318 als_usage_ids[i],
319 &st->als[i]);
320 if (ret < 0)
321 continue;
322
323 channels[index] = als_channels[i];
324 st->als_scan_mask[0] |= BIT(i);
325 channels[index].scan_type = (struct iio_scan_type) {
326 .format = 's',
327 .realbits = BYTES_TO_BITS(st->als[i].size),
328 .storagebits = BITS_PER_TYPE(u32),
329 };
330 ++index;
331
332 st->scale_precision[i] = hid_sensor_format_scale(usage_id,
333 &st->als[i], &st->scale_pre_decml[i],
334 &st->scale_post_decml[i]);
335
336 dev_dbg(&pdev->dev, "als %x:%x\n", st->als[i].index,
337 st->als[i].report_id);
338 }
339
340 st->num_channels = index;
341 /* Return success even if one usage id is present */
342 if (index)
343 ret = 0;
344
345 return ret;
346 }
347
348 /* Function to initialize the processing for usage id */
hid_als_probe(struct platform_device * pdev)349 static int hid_als_probe(struct platform_device *pdev)
350 {
351 struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
352 int ret = 0;
353 static const char *name = "als";
354 struct iio_dev *indio_dev;
355 struct als_state *als_state;
356
357 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct als_state));
358 if (!indio_dev)
359 return -ENOMEM;
360 platform_set_drvdata(pdev, indio_dev);
361
362 als_state = iio_priv(indio_dev);
363 als_state->common_attributes.hsdev = hsdev;
364 als_state->common_attributes.pdev = pdev;
365
366 ret = hid_sensor_parse_common_attributes(hsdev,
367 hsdev->usage,
368 &als_state->common_attributes,
369 als_sensitivity_addresses,
370 ARRAY_SIZE(als_sensitivity_addresses));
371 if (ret) {
372 dev_err(&pdev->dev, "failed to setup common attributes\n");
373 return ret;
374 }
375
376 ret = als_parse_report(pdev, hsdev,
377 hsdev->usage,
378 als_state);
379 if (ret) {
380 dev_err(&pdev->dev, "failed to setup attributes\n");
381 return ret;
382 }
383
384 /* Add timestamp channel */
385 als_state->channels[als_state->num_channels] = als_channels[CHANNEL_SCAN_INDEX_TIMESTAMP];
386
387 /* +1 for adding timestamp channel */
388 indio_dev->num_channels = als_state->num_channels + 1;
389
390 indio_dev->channels = als_state->channels;
391 indio_dev->available_scan_masks = als_state->als_scan_mask;
392
393 indio_dev->info = &als_info;
394 indio_dev->name = name;
395 indio_dev->modes = INDIO_DIRECT_MODE;
396
397 atomic_set(&als_state->common_attributes.data_ready, 0);
398
399 ret = hid_sensor_setup_trigger(indio_dev, name,
400 &als_state->common_attributes);
401 if (ret < 0) {
402 dev_err(&pdev->dev, "trigger setup failed\n");
403 return ret;
404 }
405
406 als_state->callbacks.send_event = als_proc_event;
407 als_state->callbacks.capture_sample = als_capture_sample;
408 als_state->callbacks.pdev = pdev;
409 ret = sensor_hub_register_callback(hsdev, hsdev->usage, &als_state->callbacks);
410 if (ret < 0) {
411 dev_err(&pdev->dev, "callback reg failed\n");
412 goto error_remove_trigger;
413 }
414
415 ret = iio_device_register(indio_dev);
416 if (ret) {
417 dev_err(&pdev->dev, "device register failed\n");
418 goto error_remove_callback;
419 }
420
421 return ret;
422
423 error_remove_callback:
424 sensor_hub_remove_callback(hsdev, hsdev->usage);
425 error_remove_trigger:
426 hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
427 return ret;
428 }
429
430 /* Function to deinitialize the processing for usage id */
hid_als_remove(struct platform_device * pdev)431 static void hid_als_remove(struct platform_device *pdev)
432 {
433 struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
434 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
435 struct als_state *als_state = iio_priv(indio_dev);
436
437 iio_device_unregister(indio_dev);
438 sensor_hub_remove_callback(hsdev, hsdev->usage);
439 hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
440 }
441
442 static const struct platform_device_id hid_als_ids[] = {
443 {
444 /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
445 .name = "HID-SENSOR-200041",
446 },
447 {
448 /* Format: HID-SENSOR-custom_sensor_tag-usage_id_in_hex_lowercase */
449 .name = "HID-SENSOR-LISS-0041",
450 },
451 { }
452 };
453 MODULE_DEVICE_TABLE(platform, hid_als_ids);
454
455 static struct platform_driver hid_als_platform_driver = {
456 .id_table = hid_als_ids,
457 .driver = {
458 .name = KBUILD_MODNAME,
459 .pm = &hid_sensor_pm_ops,
460 },
461 .probe = hid_als_probe,
462 .remove = hid_als_remove,
463 };
464 module_platform_driver(hid_als_platform_driver);
465
466 MODULE_DESCRIPTION("HID Sensor ALS");
467 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
468 MODULE_LICENSE("GPL");
469 MODULE_IMPORT_NS("IIO_HID");
470