1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * HID Sensors Driver
4  * Copyright (c) 2014, Intel Corporation.
5  */
6 #include <linux/device.h>
7 #include <linux/platform_device.h>
8 #include <linux/module.h>
9 #include <linux/interrupt.h>
10 #include <linux/irq.h>
11 #include <linux/slab.h>
12 #include <linux/delay.h>
13 #include <linux/hid-sensor-hub.h>
14 #include <linux/iio/iio.h>
15 #include <linux/iio/sysfs.h>
16 #include <linux/iio/buffer.h>
17 #include "../common/hid-sensors/hid-sensor-trigger.h"
18 
19 #define CHANNEL_SCAN_INDEX_PRESENCE 0
20 
21 struct prox_state {
22 	struct hid_sensor_hub_callbacks callbacks;
23 	struct hid_sensor_common common_attributes;
24 	struct hid_sensor_hub_attribute_info prox_attr;
25 	u32 human_presence;
26 };
27 
28 /* Channel definitions */
29 static const struct iio_chan_spec prox_channels[] = {
30 	{
31 		.type = IIO_PROXIMITY,
32 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
33 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
34 		BIT(IIO_CHAN_INFO_SCALE) |
35 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
36 		BIT(IIO_CHAN_INFO_HYSTERESIS),
37 		.scan_index = CHANNEL_SCAN_INDEX_PRESENCE,
38 	}
39 };
40 
41 /* Adjust channel real bits based on report descriptor */
42 static void prox_adjust_channel_bit_mask(struct iio_chan_spec *channels,
43 					int channel, int size)
44 {
45 	channels[channel].scan_type.sign = 's';
46 	/* Real storage bits will change based on the report desc. */
47 	channels[channel].scan_type.realbits = size * 8;
48 	/* Maximum size of a sample to capture is u32 */
49 	channels[channel].scan_type.storagebits = sizeof(u32) * 8;
50 }
51 
52 /* Channel read_raw handler */
53 static int prox_read_raw(struct iio_dev *indio_dev,
54 			      struct iio_chan_spec const *chan,
55 			      int *val, int *val2,
56 			      long mask)
57 {
58 	struct prox_state *prox_state = iio_priv(indio_dev);
59 	int report_id = -1;
60 	u32 address;
61 	int ret_type;
62 	s32 min;
63 
64 	*val = 0;
65 	*val2 = 0;
66 	switch (mask) {
67 	case IIO_CHAN_INFO_RAW:
68 		switch (chan->scan_index) {
69 		case  CHANNEL_SCAN_INDEX_PRESENCE:
70 			report_id = prox_state->prox_attr.report_id;
71 			min = prox_state->prox_attr.logical_minimum;
72 			address = HID_USAGE_SENSOR_HUMAN_PRESENCE;
73 			break;
74 		default:
75 			report_id = -1;
76 			break;
77 		}
78 		if (report_id >= 0) {
79 			hid_sensor_power_state(&prox_state->common_attributes,
80 						true);
81 			*val = sensor_hub_input_attr_get_raw_value(
82 				prox_state->common_attributes.hsdev,
83 				HID_USAGE_SENSOR_PROX, address,
84 				report_id,
85 				SENSOR_HUB_SYNC,
86 				min < 0);
87 			hid_sensor_power_state(&prox_state->common_attributes,
88 						false);
89 		} else {
90 			*val = 0;
91 			return -EINVAL;
92 		}
93 		ret_type = IIO_VAL_INT;
94 		break;
95 	case IIO_CHAN_INFO_SCALE:
96 		*val = prox_state->prox_attr.units;
97 		ret_type = IIO_VAL_INT;
98 		break;
99 	case IIO_CHAN_INFO_OFFSET:
100 		*val = hid_sensor_convert_exponent(
101 				prox_state->prox_attr.unit_expo);
102 		ret_type = IIO_VAL_INT;
103 		break;
104 	case IIO_CHAN_INFO_SAMP_FREQ:
105 		ret_type = hid_sensor_read_samp_freq_value(
106 				&prox_state->common_attributes, val, val2);
107 		break;
108 	case IIO_CHAN_INFO_HYSTERESIS:
109 		ret_type = hid_sensor_read_raw_hyst_value(
110 				&prox_state->common_attributes, val, val2);
111 		break;
112 	default:
113 		ret_type = -EINVAL;
114 		break;
115 	}
116 
117 	return ret_type;
118 }
119 
120 /* Channel write_raw handler */
121 static int prox_write_raw(struct iio_dev *indio_dev,
122 			       struct iio_chan_spec const *chan,
123 			       int val,
124 			       int val2,
125 			       long mask)
126 {
127 	struct prox_state *prox_state = iio_priv(indio_dev);
128 	int ret = 0;
129 
130 	switch (mask) {
131 	case IIO_CHAN_INFO_SAMP_FREQ:
132 		ret = hid_sensor_write_samp_freq_value(
133 				&prox_state->common_attributes, val, val2);
134 		break;
135 	case IIO_CHAN_INFO_HYSTERESIS:
136 		ret = hid_sensor_write_raw_hyst_value(
137 				&prox_state->common_attributes, val, val2);
138 		break;
139 	default:
140 		ret = -EINVAL;
141 	}
142 
143 	return ret;
144 }
145 
146 static const struct iio_info prox_info = {
147 	.read_raw = &prox_read_raw,
148 	.write_raw = &prox_write_raw,
149 };
150 
151 /* Function to push data to buffer */
152 static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data,
153 					int len)
154 {
155 	dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
156 	iio_push_to_buffers(indio_dev, data);
157 }
158 
159 /* Callback handler to send event after all samples are received and captured */
160 static int prox_proc_event(struct hid_sensor_hub_device *hsdev,
161 				unsigned usage_id,
162 				void *priv)
163 {
164 	struct iio_dev *indio_dev = platform_get_drvdata(priv);
165 	struct prox_state *prox_state = iio_priv(indio_dev);
166 
167 	dev_dbg(&indio_dev->dev, "prox_proc_event\n");
168 	if (atomic_read(&prox_state->common_attributes.data_ready))
169 		hid_sensor_push_data(indio_dev,
170 				&prox_state->human_presence,
171 				sizeof(prox_state->human_presence));
172 
173 	return 0;
174 }
175 
176 /* Capture samples in local storage */
177 static int prox_capture_sample(struct hid_sensor_hub_device *hsdev,
178 				unsigned usage_id,
179 				size_t raw_len, char *raw_data,
180 				void *priv)
181 {
182 	struct iio_dev *indio_dev = platform_get_drvdata(priv);
183 	struct prox_state *prox_state = iio_priv(indio_dev);
184 	int ret = -EINVAL;
185 
186 	switch (usage_id) {
187 	case HID_USAGE_SENSOR_HUMAN_PRESENCE:
188 		prox_state->human_presence = *(u32 *)raw_data;
189 		ret = 0;
190 		break;
191 	default:
192 		break;
193 	}
194 
195 	return ret;
196 }
197 
198 /* Parse report which is specific to an usage id*/
199 static int prox_parse_report(struct platform_device *pdev,
200 				struct hid_sensor_hub_device *hsdev,
201 				struct iio_chan_spec *channels,
202 				unsigned usage_id,
203 				struct prox_state *st)
204 {
205 	int ret;
206 
207 	ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
208 			usage_id,
209 			HID_USAGE_SENSOR_HUMAN_PRESENCE,
210 			&st->prox_attr);
211 	if (ret < 0)
212 		return ret;
213 	prox_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_PRESENCE,
214 					st->prox_attr.size);
215 
216 	dev_dbg(&pdev->dev, "prox %x:%x\n", st->prox_attr.index,
217 			st->prox_attr.report_id);
218 
219 	/* Set Sensitivity field ids, when there is no individual modifier */
220 	if (st->common_attributes.sensitivity.index < 0) {
221 		sensor_hub_input_get_attribute_info(hsdev,
222 			HID_FEATURE_REPORT, usage_id,
223 			HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
224 			HID_USAGE_SENSOR_DATA_PRESENCE,
225 			&st->common_attributes.sensitivity);
226 		dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
227 			st->common_attributes.sensitivity.index,
228 			st->common_attributes.sensitivity.report_id);
229 	}
230 	if (st->common_attributes.sensitivity.index < 0)
231 		sensor_hub_input_get_attribute_info(hsdev,
232 			HID_FEATURE_REPORT, usage_id,
233 			HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
234 			HID_USAGE_SENSOR_HUMAN_PRESENCE,
235 			&st->common_attributes.sensitivity);
236 
237 	return ret;
238 }
239 
240 /* Function to initialize the processing for usage id */
241 static int hid_prox_probe(struct platform_device *pdev)
242 {
243 	int ret = 0;
244 	static const char *name = "prox";
245 	struct iio_dev *indio_dev;
246 	struct prox_state *prox_state;
247 	struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
248 
249 	indio_dev = devm_iio_device_alloc(&pdev->dev,
250 				sizeof(struct prox_state));
251 	if (!indio_dev)
252 		return -ENOMEM;
253 	platform_set_drvdata(pdev, indio_dev);
254 
255 	prox_state = iio_priv(indio_dev);
256 	prox_state->common_attributes.hsdev = hsdev;
257 	prox_state->common_attributes.pdev = pdev;
258 
259 	ret = hid_sensor_parse_common_attributes(hsdev, HID_USAGE_SENSOR_PROX,
260 					&prox_state->common_attributes);
261 	if (ret) {
262 		dev_err(&pdev->dev, "failed to setup common attributes\n");
263 		return ret;
264 	}
265 
266 	indio_dev->channels = kmemdup(prox_channels, sizeof(prox_channels),
267 				      GFP_KERNEL);
268 	if (!indio_dev->channels) {
269 		dev_err(&pdev->dev, "failed to duplicate channels\n");
270 		return -ENOMEM;
271 	}
272 
273 	ret = prox_parse_report(pdev, hsdev,
274 				(struct iio_chan_spec *)indio_dev->channels,
275 				HID_USAGE_SENSOR_PROX, prox_state);
276 	if (ret) {
277 		dev_err(&pdev->dev, "failed to setup attributes\n");
278 		goto error_free_dev_mem;
279 	}
280 
281 	indio_dev->num_channels = ARRAY_SIZE(prox_channels);
282 	indio_dev->dev.parent = &pdev->dev;
283 	indio_dev->info = &prox_info;
284 	indio_dev->name = name;
285 	indio_dev->modes = INDIO_DIRECT_MODE;
286 
287 	atomic_set(&prox_state->common_attributes.data_ready, 0);
288 
289 	ret = hid_sensor_setup_trigger(indio_dev, name,
290 				&prox_state->common_attributes);
291 	if (ret) {
292 		dev_err(&pdev->dev, "trigger setup failed\n");
293 		goto error_free_dev_mem;
294 	}
295 
296 	ret = iio_device_register(indio_dev);
297 	if (ret) {
298 		dev_err(&pdev->dev, "device register failed\n");
299 		goto error_remove_trigger;
300 	}
301 
302 	prox_state->callbacks.send_event = prox_proc_event;
303 	prox_state->callbacks.capture_sample = prox_capture_sample;
304 	prox_state->callbacks.pdev = pdev;
305 	ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_PROX,
306 					&prox_state->callbacks);
307 	if (ret < 0) {
308 		dev_err(&pdev->dev, "callback reg failed\n");
309 		goto error_iio_unreg;
310 	}
311 
312 	return ret;
313 
314 error_iio_unreg:
315 	iio_device_unregister(indio_dev);
316 error_remove_trigger:
317 	hid_sensor_remove_trigger(indio_dev, &prox_state->common_attributes);
318 error_free_dev_mem:
319 	kfree(indio_dev->channels);
320 	return ret;
321 }
322 
323 /* Function to deinitialize the processing for usage id */
324 static int hid_prox_remove(struct platform_device *pdev)
325 {
326 	struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
327 	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
328 	struct prox_state *prox_state = iio_priv(indio_dev);
329 
330 	sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_PROX);
331 	iio_device_unregister(indio_dev);
332 	hid_sensor_remove_trigger(indio_dev, &prox_state->common_attributes);
333 	kfree(indio_dev->channels);
334 
335 	return 0;
336 }
337 
338 static const struct platform_device_id hid_prox_ids[] = {
339 	{
340 		/* Format: HID-SENSOR-usage_id_in_hex_lowercase */
341 		.name = "HID-SENSOR-200011",
342 	},
343 	{ /* sentinel */ }
344 };
345 MODULE_DEVICE_TABLE(platform, hid_prox_ids);
346 
347 static struct platform_driver hid_prox_platform_driver = {
348 	.id_table = hid_prox_ids,
349 	.driver = {
350 		.name	= KBUILD_MODNAME,
351 		.pm	= &hid_sensor_pm_ops,
352 	},
353 	.probe		= hid_prox_probe,
354 	.remove		= hid_prox_remove,
355 };
356 module_platform_driver(hid_prox_platform_driver);
357 
358 MODULE_DESCRIPTION("HID Sensor Proximity");
359 MODULE_AUTHOR("Archana Patni <archana.patni@intel.com>");
360 MODULE_LICENSE("GPL");
361