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