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