hid-sensor-als.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * HID Sensors Driver
  4 * Copyright (c) 2012, Intel Corporation.
  5 */
  6#include <linux/device.h>
  7#include <linux/platform_device.h>
  8#include <linux/module.h>
  9#include <linux/mod_devicetable.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
 16enum {
 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
 27struct 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;
 37	int scale_post_decml;
 38	int scale_precision;
 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 */
 46static 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
 54static const u32 als_sensitivity_addresses[] = {
 55	HID_USAGE_SENSOR_DATA_LIGHT,
 56	HID_USAGE_SENSOR_LIGHT_ILLUM,
 57};
 58
 59/* Channel definitions */
 60static 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/* Adjust channel real bits based on report descriptor */
121static void als_adjust_channel_bit_mask(struct iio_chan_spec *channels,
122					int channel, int size)
123{
124	channels[channel].scan_type.sign = 's';
125	/* Real storage bits will change based on the report desc. */
126	channels[channel].scan_type.realbits = size * 8;
127	/* Maximum size of a sample to capture is u32 */
128	channels[channel].scan_type.storagebits = sizeof(u32) * 8;
129}
130
131/* Channel read_raw handler */
132static int als_read_raw(struct iio_dev *indio_dev,
133			      struct iio_chan_spec const *chan,
134			      int *val, int *val2,
135			      long mask)
136{
137	struct als_state *als_state = iio_priv(indio_dev);
138	struct hid_sensor_hub_device *hsdev = als_state->common_attributes.hsdev;
139	int report_id = -1;
140	u32 address;
141	int ret_type;
142	s32 min;
143
144	*val = 0;
145	*val2 = 0;
146	switch (mask) {
147	case IIO_CHAN_INFO_RAW:
148		switch (chan->scan_index) {
149		case  CHANNEL_SCAN_INDEX_INTENSITY:
150		case  CHANNEL_SCAN_INDEX_ILLUM:
151			report_id = als_state->als[chan->scan_index].report_id;
152			min = als_state->als[chan->scan_index].logical_minimum;
153			address = HID_USAGE_SENSOR_LIGHT_ILLUM;
154			break;
155		case  CHANNEL_SCAN_INDEX_COLOR_TEMP:
156			report_id = als_state->als[chan->scan_index].report_id;
157			min = als_state->als[chan->scan_index].logical_minimum;
158			address = HID_USAGE_SENSOR_LIGHT_COLOR_TEMPERATURE;
159			break;
160		case  CHANNEL_SCAN_INDEX_CHROMATICITY_X:
161			report_id = als_state->als[chan->scan_index].report_id;
162			min = als_state->als[chan->scan_index].logical_minimum;
163			address = HID_USAGE_SENSOR_LIGHT_CHROMATICITY_X;
164			break;
165		case  CHANNEL_SCAN_INDEX_CHROMATICITY_Y:
166			report_id = als_state->als[chan->scan_index].report_id;
167			min = als_state->als[chan->scan_index].logical_minimum;
168			address = HID_USAGE_SENSOR_LIGHT_CHROMATICITY_Y;
169			break;
170		default:
171			report_id = -1;
172			break;
173		}
174		if (report_id >= 0) {
175			hid_sensor_power_state(&als_state->common_attributes,
176						true);
177			*val = sensor_hub_input_attr_get_raw_value(
178					hsdev, hsdev->usage, address, report_id,
179					SENSOR_HUB_SYNC, min < 0);
180			hid_sensor_power_state(&als_state->common_attributes,
181						false);
182		} else {
183			*val = 0;
184			return -EINVAL;
185		}
186		ret_type = IIO_VAL_INT;
187		break;
188	case IIO_CHAN_INFO_SCALE:
189		*val = als_state->scale_pre_decml;
190		*val2 = als_state->scale_post_decml;
191		ret_type = als_state->scale_precision;
192		break;
193	case IIO_CHAN_INFO_OFFSET:
194		*val = als_state->value_offset;
195		ret_type = IIO_VAL_INT;
196		break;
197	case IIO_CHAN_INFO_SAMP_FREQ:
198		ret_type = hid_sensor_read_samp_freq_value(
199				&als_state->common_attributes, val, val2);
200		break;
201	case IIO_CHAN_INFO_HYSTERESIS:
202		ret_type = hid_sensor_read_raw_hyst_value(
203				&als_state->common_attributes, val, val2);
204		break;
205	case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
206		ret_type = hid_sensor_read_raw_hyst_rel_value(
207				&als_state->common_attributes, val, val2);
208		break;
209	default:
210		ret_type = -EINVAL;
211		break;
212	}
213
214	return ret_type;
215}
216
217/* Channel write_raw handler */
218static int als_write_raw(struct iio_dev *indio_dev,
219			       struct iio_chan_spec const *chan,
220			       int val,
221			       int val2,
222			       long mask)
223{
224	struct als_state *als_state = iio_priv(indio_dev);
225	int ret = 0;
226
227	switch (mask) {
228	case IIO_CHAN_INFO_SAMP_FREQ:
229		ret = hid_sensor_write_samp_freq_value(
230				&als_state->common_attributes, val, val2);
231		break;
232	case IIO_CHAN_INFO_HYSTERESIS:
233		ret = hid_sensor_write_raw_hyst_value(
234				&als_state->common_attributes, val, val2);
235		break;
236	case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
237		ret = hid_sensor_write_raw_hyst_rel_value(
238				&als_state->common_attributes, val, val2);
239		break;
240	default:
241		ret = -EINVAL;
242	}
243
244	return ret;
245}
246
247static const struct iio_info als_info = {
248	.read_raw = &als_read_raw,
249	.write_raw = &als_write_raw,
250};
251
252/* Callback handler to send event after all samples are received and captured */
253static int als_proc_event(struct hid_sensor_hub_device *hsdev,
254				unsigned usage_id,
255				void *priv)
256{
257	struct iio_dev *indio_dev = platform_get_drvdata(priv);
258	struct als_state *als_state = iio_priv(indio_dev);
259
260	dev_dbg(&indio_dev->dev, "als_proc_event\n");
261	if (atomic_read(&als_state->common_attributes.data_ready)) {
262		if (!als_state->timestamp)
263			als_state->timestamp = iio_get_time_ns(indio_dev);
264
265		iio_push_to_buffers_with_ts(indio_dev, &als_state->scan,
266					    sizeof(als_state->scan),
267					    als_state->timestamp);
268		als_state->timestamp = 0;
269	}
270
271	return 0;
272}
273
274/* Capture samples in local storage */
275static int als_capture_sample(struct hid_sensor_hub_device *hsdev,
276				unsigned usage_id,
277				size_t raw_len, char *raw_data,
278				void *priv)
279{
280	struct iio_dev *indio_dev = platform_get_drvdata(priv);
281	struct als_state *als_state = iio_priv(indio_dev);
282	int ret = -EINVAL;
283	u32 sample_data = *(u32 *)raw_data;
284
285	switch (usage_id) {
286	case HID_USAGE_SENSOR_LIGHT_ILLUM:
287		als_state->scan.illum[CHANNEL_SCAN_INDEX_INTENSITY] = sample_data;
288		als_state->scan.illum[CHANNEL_SCAN_INDEX_ILLUM] = sample_data;
289		ret = 0;
290		break;
291	case HID_USAGE_SENSOR_LIGHT_COLOR_TEMPERATURE:
292		als_state->scan.illum[CHANNEL_SCAN_INDEX_COLOR_TEMP] = sample_data;
293		ret = 0;
294		break;
295	case HID_USAGE_SENSOR_LIGHT_CHROMATICITY_X:
296		als_state->scan.illum[CHANNEL_SCAN_INDEX_CHROMATICITY_X] = sample_data;
297		ret = 0;
298		break;
299	case HID_USAGE_SENSOR_LIGHT_CHROMATICITY_Y:
300		als_state->scan.illum[CHANNEL_SCAN_INDEX_CHROMATICITY_Y] = sample_data;
301		ret = 0;
302		break;
303	case HID_USAGE_SENSOR_TIME_TIMESTAMP:
304		als_state->timestamp = hid_sensor_convert_timestamp(&als_state->common_attributes,
305								    *(s64 *)raw_data);
306		ret = 0;
307		break;
308	default:
309		break;
310	}
311
312	return ret;
313}
314
315/* Parse report which is specific to an usage id*/
316static int als_parse_report(struct platform_device *pdev,
317				struct hid_sensor_hub_device *hsdev,
318				unsigned usage_id,
319				struct als_state *st)
320{
321	struct iio_chan_spec *channels;
322	int ret, index = 0;
323	int i;
324
325	channels = st->channels;
326
327	for (i = 0; i < CHANNEL_SCAN_INDEX_MAX; ++i) {
328		ret = sensor_hub_input_get_attribute_info(hsdev,
329						HID_INPUT_REPORT,
330						usage_id,
331						als_usage_ids[i],
332						&st->als[i]);
333		if (ret < 0)
334			continue;
335
336		channels[index] = als_channels[i];
337		st->als_scan_mask[0] |= BIT(i);
338		als_adjust_channel_bit_mask(channels, index, st->als[i].size);
339		++index;
340
341		dev_dbg(&pdev->dev, "als %x:%x\n", st->als[i].index,
342			st->als[i].report_id);
343	}
344
345	st->num_channels = index;
346	/* Return success even if one usage id is present */
347	if (index)
348		ret = 0;
349
350	st->scale_precision = hid_sensor_format_scale(usage_id,
351				&st->als[CHANNEL_SCAN_INDEX_INTENSITY],
352				&st->scale_pre_decml, &st->scale_post_decml);
353
354	return ret;
355}
356
357/* Function to initialize the processing for usage id */
358static int hid_als_probe(struct platform_device *pdev)
359{
360	struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
361	int ret = 0;
362	static const char *name = "als";
363	struct iio_dev *indio_dev;
364	struct als_state *als_state;
365
366	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct als_state));
367	if (!indio_dev)
368		return -ENOMEM;
369	platform_set_drvdata(pdev, indio_dev);
370
371	als_state = iio_priv(indio_dev);
372	als_state->common_attributes.hsdev = hsdev;
373	als_state->common_attributes.pdev = pdev;
374
375	ret = hid_sensor_parse_common_attributes(hsdev,
376					hsdev->usage,
377					&als_state->common_attributes,
378					als_sensitivity_addresses,
379					ARRAY_SIZE(als_sensitivity_addresses));
380	if (ret) {
381		dev_err(&pdev->dev, "failed to setup common attributes\n");
382		return ret;
383	}
384
385	ret = als_parse_report(pdev, hsdev,
386			       hsdev->usage,
387			       als_state);
388	if (ret) {
389		dev_err(&pdev->dev, "failed to setup attributes\n");
390		return ret;
391	}
392
393	/* Add timestamp channel */
394	als_state->channels[als_state->num_channels] = als_channels[CHANNEL_SCAN_INDEX_TIMESTAMP];
395
396	/* +1 for adding timestamp channel */
397	indio_dev->num_channels = als_state->num_channels + 1;
398
399	indio_dev->channels = als_state->channels;
400	indio_dev->available_scan_masks = als_state->als_scan_mask;
401
402	indio_dev->info = &als_info;
403	indio_dev->name = name;
404	indio_dev->modes = INDIO_DIRECT_MODE;
405
406	atomic_set(&als_state->common_attributes.data_ready, 0);
407
408	ret = hid_sensor_setup_trigger(indio_dev, name,
409				&als_state->common_attributes);
410	if (ret < 0) {
411		dev_err(&pdev->dev, "trigger setup failed\n");
412		return ret;
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_trigger;
419	}
420
421	als_state->callbacks.send_event = als_proc_event;
422	als_state->callbacks.capture_sample = als_capture_sample;
423	als_state->callbacks.pdev = pdev;
424	ret = sensor_hub_register_callback(hsdev, hsdev->usage, &als_state->callbacks);
425	if (ret < 0) {
426		dev_err(&pdev->dev, "callback reg failed\n");
427		goto error_iio_unreg;
428	}
429
430	return ret;
431
432error_iio_unreg:
433	iio_device_unregister(indio_dev);
434error_remove_trigger:
435	hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
436	return ret;
437}
438
439/* Function to deinitialize the processing for usage id */
440static void hid_als_remove(struct platform_device *pdev)
441{
442	struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
443	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
444	struct als_state *als_state = iio_priv(indio_dev);
445
446	sensor_hub_remove_callback(hsdev, hsdev->usage);
447	iio_device_unregister(indio_dev);
448	hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
449}
450
451static const struct platform_device_id hid_als_ids[] = {
452	{
453		/* Format: HID-SENSOR-usage_id_in_hex_lowercase */
454		.name = "HID-SENSOR-200041",
455	},
456	{
457		/* Format: HID-SENSOR-custom_sensor_tag-usage_id_in_hex_lowercase */
458		.name = "HID-SENSOR-LISS-0041",
459	},
460	{ }
461};
462MODULE_DEVICE_TABLE(platform, hid_als_ids);
463
464static struct platform_driver hid_als_platform_driver = {
465	.id_table = hid_als_ids,
466	.driver = {
467		.name	= KBUILD_MODNAME,
468		.pm	= &hid_sensor_pm_ops,
469	},
470	.probe		= hid_als_probe,
471	.remove		= hid_als_remove,
472};
473module_platform_driver(hid_als_platform_driver);
474
475MODULE_DESCRIPTION("HID Sensor ALS");
476MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
477MODULE_LICENSE("GPL");
478MODULE_IMPORT_NS("IIO_HID");