• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/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 enum magn_3d_channel {
20 	CHANNEL_SCAN_INDEX_X,
21 	CHANNEL_SCAN_INDEX_Y,
22 	CHANNEL_SCAN_INDEX_Z,
23 	CHANNEL_SCAN_INDEX_NORTH_MAGN_TILT_COMP,
24 	CHANNEL_SCAN_INDEX_NORTH_TRUE_TILT_COMP,
25 	CHANNEL_SCAN_INDEX_NORTH_MAGN,
26 	CHANNEL_SCAN_INDEX_NORTH_TRUE,
27 	MAGN_3D_CHANNEL_MAX,
28 };
29 
30 struct common_attributes {
31 	int scale_pre_decml;
32 	int scale_post_decml;
33 	int scale_precision;
34 	int value_offset;
35 };
36 
37 struct magn_3d_state {
38 	struct hid_sensor_hub_callbacks callbacks;
39 	struct hid_sensor_common magn_flux_attributes;
40 	struct hid_sensor_common rot_attributes;
41 	struct hid_sensor_hub_attribute_info magn[MAGN_3D_CHANNEL_MAX];
42 
43 	/* dynamically sized array to hold sensor values */
44 	u32 *iio_vals;
45 	/* array of pointers to sensor value */
46 	u32 *magn_val_addr[MAGN_3D_CHANNEL_MAX];
47 
48 	struct common_attributes magn_flux_attr;
49 	struct common_attributes rot_attr;
50 };
51 
52 static const u32 magn_3d_addresses[MAGN_3D_CHANNEL_MAX] = {
53 	HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_X_AXIS,
54 	HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Y_AXIS,
55 	HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Z_AXIS,
56 	HID_USAGE_SENSOR_ORIENT_COMP_MAGN_NORTH,
57 	HID_USAGE_SENSOR_ORIENT_COMP_TRUE_NORTH,
58 	HID_USAGE_SENSOR_ORIENT_MAGN_NORTH,
59 	HID_USAGE_SENSOR_ORIENT_TRUE_NORTH,
60 };
61 
62 /* Channel definitions */
63 static const struct iio_chan_spec magn_3d_channels[] = {
64 	{
65 		.type = IIO_MAGN,
66 		.modified = 1,
67 		.channel2 = IIO_MOD_X,
68 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
69 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
70 		BIT(IIO_CHAN_INFO_SCALE) |
71 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
72 		BIT(IIO_CHAN_INFO_HYSTERESIS),
73 	}, {
74 		.type = IIO_MAGN,
75 		.modified = 1,
76 		.channel2 = IIO_MOD_Y,
77 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
78 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
79 		BIT(IIO_CHAN_INFO_SCALE) |
80 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
81 		BIT(IIO_CHAN_INFO_HYSTERESIS),
82 	}, {
83 		.type = IIO_MAGN,
84 		.modified = 1,
85 		.channel2 = IIO_MOD_Z,
86 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
87 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
88 		BIT(IIO_CHAN_INFO_SCALE) |
89 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
90 		BIT(IIO_CHAN_INFO_HYSTERESIS),
91 	}, {
92 		.type = IIO_ROT,
93 		.modified = 1,
94 		.channel2 = IIO_MOD_NORTH_MAGN_TILT_COMP,
95 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
96 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
97 		BIT(IIO_CHAN_INFO_SCALE) |
98 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
99 		BIT(IIO_CHAN_INFO_HYSTERESIS),
100 	}, {
101 		.type = IIO_ROT,
102 		.modified = 1,
103 		.channel2 = IIO_MOD_NORTH_TRUE_TILT_COMP,
104 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
105 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
106 		BIT(IIO_CHAN_INFO_SCALE) |
107 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
108 		BIT(IIO_CHAN_INFO_HYSTERESIS),
109 	}, {
110 		.type = IIO_ROT,
111 		.modified = 1,
112 		.channel2 = IIO_MOD_NORTH_MAGN,
113 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
114 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
115 		BIT(IIO_CHAN_INFO_SCALE) |
116 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
117 		BIT(IIO_CHAN_INFO_HYSTERESIS),
118 	}, {
119 		.type = IIO_ROT,
120 		.modified = 1,
121 		.channel2 = IIO_MOD_NORTH_TRUE,
122 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
123 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
124 		BIT(IIO_CHAN_INFO_SCALE) |
125 		BIT(IIO_CHAN_INFO_SAMP_FREQ) |
126 		BIT(IIO_CHAN_INFO_HYSTERESIS),
127 	}
128 };
129 
130 /* Adjust channel real bits based on report descriptor */
magn_3d_adjust_channel_bit_mask(struct iio_chan_spec * channels,int channel,int size)131 static void magn_3d_adjust_channel_bit_mask(struct iio_chan_spec *channels,
132 						int channel, int size)
133 {
134 	channels[channel].scan_type.sign = 's';
135 	/* Real storage bits will change based on the report desc. */
136 	channels[channel].scan_type.realbits = size * 8;
137 	/* Maximum size of a sample to capture is u32 */
138 	channels[channel].scan_type.storagebits = sizeof(u32) * 8;
139 }
140 
141 /* Channel read_raw handler */
magn_3d_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)142 static int magn_3d_read_raw(struct iio_dev *indio_dev,
143 			      struct iio_chan_spec const *chan,
144 			      int *val, int *val2,
145 			      long mask)
146 {
147 	struct magn_3d_state *magn_state = iio_priv(indio_dev);
148 	int report_id = -1;
149 	u32 address;
150 	int ret_type;
151 	s32 min;
152 
153 	*val = 0;
154 	*val2 = 0;
155 	switch (mask) {
156 	case IIO_CHAN_INFO_RAW:
157 		hid_sensor_power_state(&magn_state->magn_flux_attributes, true);
158 		report_id = magn_state->magn[chan->address].report_id;
159 		min = magn_state->magn[chan->address].logical_minimum;
160 		address = magn_3d_addresses[chan->address];
161 		if (report_id >= 0)
162 			*val = sensor_hub_input_attr_get_raw_value(
163 				magn_state->magn_flux_attributes.hsdev,
164 				HID_USAGE_SENSOR_COMPASS_3D, address,
165 				report_id,
166 				SENSOR_HUB_SYNC,
167 				min < 0);
168 		else {
169 			*val = 0;
170 			hid_sensor_power_state(
171 				&magn_state->magn_flux_attributes,
172 				false);
173 			return -EINVAL;
174 		}
175 		hid_sensor_power_state(&magn_state->magn_flux_attributes,
176 					false);
177 		ret_type = IIO_VAL_INT;
178 		break;
179 	case IIO_CHAN_INFO_SCALE:
180 		switch (chan->type) {
181 		case IIO_MAGN:
182 			*val = magn_state->magn_flux_attr.scale_pre_decml;
183 			*val2 = magn_state->magn_flux_attr.scale_post_decml;
184 			ret_type = magn_state->magn_flux_attr.scale_precision;
185 			break;
186 		case IIO_ROT:
187 			*val = magn_state->rot_attr.scale_pre_decml;
188 			*val2 = magn_state->rot_attr.scale_post_decml;
189 			ret_type = magn_state->rot_attr.scale_precision;
190 			break;
191 		default:
192 			ret_type = -EINVAL;
193 		}
194 		break;
195 	case IIO_CHAN_INFO_OFFSET:
196 		switch (chan->type) {
197 		case IIO_MAGN:
198 			*val = magn_state->magn_flux_attr.value_offset;
199 			ret_type = IIO_VAL_INT;
200 			break;
201 		case IIO_ROT:
202 			*val = magn_state->rot_attr.value_offset;
203 			ret_type = IIO_VAL_INT;
204 			break;
205 		default:
206 			ret_type = -EINVAL;
207 		}
208 		break;
209 	case IIO_CHAN_INFO_SAMP_FREQ:
210 		ret_type = hid_sensor_read_samp_freq_value(
211 			&magn_state->magn_flux_attributes, val, val2);
212 		break;
213 	case IIO_CHAN_INFO_HYSTERESIS:
214 		switch (chan->type) {
215 		case IIO_MAGN:
216 			ret_type = hid_sensor_read_raw_hyst_value(
217 				&magn_state->magn_flux_attributes, val, val2);
218 			break;
219 		case IIO_ROT:
220 			ret_type = hid_sensor_read_raw_hyst_value(
221 				&magn_state->rot_attributes, val, val2);
222 			break;
223 		default:
224 			ret_type = -EINVAL;
225 		}
226 		break;
227 	default:
228 		ret_type = -EINVAL;
229 		break;
230 	}
231 
232 	return ret_type;
233 }
234 
235 /* Channel write_raw handler */
magn_3d_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)236 static int magn_3d_write_raw(struct iio_dev *indio_dev,
237 			       struct iio_chan_spec const *chan,
238 			       int val,
239 			       int val2,
240 			       long mask)
241 {
242 	struct magn_3d_state *magn_state = iio_priv(indio_dev);
243 	int ret = 0;
244 
245 	switch (mask) {
246 	case IIO_CHAN_INFO_SAMP_FREQ:
247 		ret = hid_sensor_write_samp_freq_value(
248 				&magn_state->magn_flux_attributes, val, val2);
249 		break;
250 	case IIO_CHAN_INFO_HYSTERESIS:
251 		switch (chan->type) {
252 		case IIO_MAGN:
253 			ret = hid_sensor_write_raw_hyst_value(
254 				&magn_state->magn_flux_attributes, val, val2);
255 			break;
256 		case IIO_ROT:
257 			ret = hid_sensor_write_raw_hyst_value(
258 				&magn_state->rot_attributes, val, val2);
259 			break;
260 		default:
261 			ret = -EINVAL;
262 		}
263 		break;
264 	default:
265 		ret = -EINVAL;
266 	}
267 
268 	return ret;
269 }
270 
271 static const struct iio_info magn_3d_info = {
272 	.read_raw = &magn_3d_read_raw,
273 	.write_raw = &magn_3d_write_raw,
274 };
275 
276 /* Function to push data to buffer */
hid_sensor_push_data(struct iio_dev * indio_dev,const void * data)277 static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data)
278 {
279 	dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
280 	iio_push_to_buffers(indio_dev, data);
281 }
282 
283 /* Callback handler to send event after all samples are received and captured */
magn_3d_proc_event(struct hid_sensor_hub_device * hsdev,unsigned usage_id,void * priv)284 static int magn_3d_proc_event(struct hid_sensor_hub_device *hsdev,
285 				unsigned usage_id,
286 				void *priv)
287 {
288 	struct iio_dev *indio_dev = platform_get_drvdata(priv);
289 	struct magn_3d_state *magn_state = iio_priv(indio_dev);
290 
291 	dev_dbg(&indio_dev->dev, "magn_3d_proc_event\n");
292 	if (atomic_read(&magn_state->magn_flux_attributes.data_ready))
293 		hid_sensor_push_data(indio_dev, magn_state->iio_vals);
294 
295 	return 0;
296 }
297 
298 /* Capture samples in local storage */
magn_3d_capture_sample(struct hid_sensor_hub_device * hsdev,unsigned usage_id,size_t raw_len,char * raw_data,void * priv)299 static int magn_3d_capture_sample(struct hid_sensor_hub_device *hsdev,
300 				unsigned usage_id,
301 				size_t raw_len, char *raw_data,
302 				void *priv)
303 {
304 	struct iio_dev *indio_dev = platform_get_drvdata(priv);
305 	struct magn_3d_state *magn_state = iio_priv(indio_dev);
306 	int offset;
307 	int ret = 0;
308 	u32 *iio_val = NULL;
309 
310 	switch (usage_id) {
311 	case HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_X_AXIS:
312 	case HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Y_AXIS:
313 	case HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Z_AXIS:
314 		offset = (usage_id - HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_X_AXIS)
315 				+ CHANNEL_SCAN_INDEX_X;
316 	break;
317 	case HID_USAGE_SENSOR_ORIENT_COMP_MAGN_NORTH:
318 	case HID_USAGE_SENSOR_ORIENT_COMP_TRUE_NORTH:
319 	case HID_USAGE_SENSOR_ORIENT_MAGN_NORTH:
320 	case HID_USAGE_SENSOR_ORIENT_TRUE_NORTH:
321 		offset = (usage_id - HID_USAGE_SENSOR_ORIENT_COMP_MAGN_NORTH)
322 				+ CHANNEL_SCAN_INDEX_NORTH_MAGN_TILT_COMP;
323 	break;
324 	default:
325 		return -EINVAL;
326 	}
327 
328 	iio_val = magn_state->magn_val_addr[offset];
329 
330 	if (iio_val != NULL)
331 		*iio_val = *((u32 *)raw_data);
332 	else
333 		ret = -EINVAL;
334 
335 	return ret;
336 }
337 
338 /* Parse report which is specific to an usage id*/
magn_3d_parse_report(struct platform_device * pdev,struct hid_sensor_hub_device * hsdev,struct iio_chan_spec ** channels,int * chan_count,unsigned usage_id,struct magn_3d_state * st)339 static int magn_3d_parse_report(struct platform_device *pdev,
340 				struct hid_sensor_hub_device *hsdev,
341 				struct iio_chan_spec **channels,
342 				int *chan_count,
343 				unsigned usage_id,
344 				struct magn_3d_state *st)
345 {
346 	int i;
347 	int attr_count = 0;
348 	struct iio_chan_spec *_channels;
349 
350 	/* Scan for each usage attribute supported */
351 	for (i = 0; i < MAGN_3D_CHANNEL_MAX; i++) {
352 		int status;
353 		u32 address = magn_3d_addresses[i];
354 
355 		/* Check if usage attribute exists in the sensor hub device */
356 		status = sensor_hub_input_get_attribute_info(hsdev,
357 			HID_INPUT_REPORT,
358 			usage_id,
359 			address,
360 			&(st->magn[i]));
361 		if (!status)
362 			attr_count++;
363 	}
364 
365 	if (attr_count <= 0) {
366 		dev_err(&pdev->dev,
367 			"failed to find any supported usage attributes in report\n");
368 		return  -EINVAL;
369 	}
370 
371 	dev_dbg(&pdev->dev, "magn_3d Found %d usage attributes\n",
372 			attr_count);
373 	dev_dbg(&pdev->dev, "magn_3d X: %x:%x Y: %x:%x Z: %x:%x\n",
374 			st->magn[0].index,
375 			st->magn[0].report_id,
376 			st->magn[1].index, st->magn[1].report_id,
377 			st->magn[2].index, st->magn[2].report_id);
378 
379 	/* Setup IIO channel array */
380 	_channels = devm_kcalloc(&pdev->dev, attr_count,
381 				sizeof(struct iio_chan_spec),
382 				GFP_KERNEL);
383 	if (!_channels) {
384 		dev_err(&pdev->dev,
385 			"failed to allocate space for iio channels\n");
386 		return -ENOMEM;
387 	}
388 
389 	st->iio_vals = devm_kcalloc(&pdev->dev, attr_count,
390 				sizeof(u32),
391 				GFP_KERNEL);
392 	if (!st->iio_vals) {
393 		dev_err(&pdev->dev,
394 			"failed to allocate space for iio values array\n");
395 		return -ENOMEM;
396 	}
397 
398 	for (i = 0, *chan_count = 0;
399 	i < MAGN_3D_CHANNEL_MAX && *chan_count < attr_count;
400 	i++){
401 		if (st->magn[i].index >= 0) {
402 			/* Setup IIO channel struct */
403 			(_channels[*chan_count]) = magn_3d_channels[i];
404 			(_channels[*chan_count]).scan_index = *chan_count;
405 			(_channels[*chan_count]).address = i;
406 
407 			/* Set magn_val_addr to iio value address */
408 			st->magn_val_addr[i] = &(st->iio_vals[*chan_count]);
409 			magn_3d_adjust_channel_bit_mask(_channels,
410 							*chan_count,
411 							st->magn[i].size);
412 			(*chan_count)++;
413 		}
414 	}
415 
416 	if (*chan_count <= 0) {
417 		dev_err(&pdev->dev,
418 			"failed to find any magnetic channels setup\n");
419 		return -EINVAL;
420 	}
421 
422 	*channels = _channels;
423 
424 	dev_dbg(&pdev->dev, "magn_3d Setup %d IIO channels\n",
425 			*chan_count);
426 
427 	st->magn_flux_attr.scale_precision = hid_sensor_format_scale(
428 				HID_USAGE_SENSOR_COMPASS_3D,
429 				&st->magn[CHANNEL_SCAN_INDEX_X],
430 				&st->magn_flux_attr.scale_pre_decml,
431 				&st->magn_flux_attr.scale_post_decml);
432 	st->rot_attr.scale_precision
433 		= hid_sensor_format_scale(
434 			HID_USAGE_SENSOR_ORIENT_COMP_MAGN_NORTH,
435 			&st->magn[CHANNEL_SCAN_INDEX_NORTH_MAGN_TILT_COMP],
436 			&st->rot_attr.scale_pre_decml,
437 			&st->rot_attr.scale_post_decml);
438 
439 	/* Set Sensitivity field ids, when there is no individual modifier */
440 	if (st->magn_flux_attributes.sensitivity.index < 0) {
441 		sensor_hub_input_get_attribute_info(hsdev,
442 			HID_FEATURE_REPORT, usage_id,
443 			HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
444 			HID_USAGE_SENSOR_DATA_ORIENTATION,
445 			&st->magn_flux_attributes.sensitivity);
446 		dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
447 			st->magn_flux_attributes.sensitivity.index,
448 			st->magn_flux_attributes.sensitivity.report_id);
449 	}
450 	if (st->magn_flux_attributes.sensitivity.index < 0) {
451 		sensor_hub_input_get_attribute_info(hsdev,
452 			HID_FEATURE_REPORT, usage_id,
453 			HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
454 			HID_USAGE_SENSOR_ORIENT_MAGN_FLUX,
455 			&st->magn_flux_attributes.sensitivity);
456 		dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
457 			st->magn_flux_attributes.sensitivity.index,
458 			st->magn_flux_attributes.sensitivity.report_id);
459 	}
460 	if (st->rot_attributes.sensitivity.index < 0) {
461 		sensor_hub_input_get_attribute_info(hsdev,
462 			HID_FEATURE_REPORT, usage_id,
463 			HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
464 			HID_USAGE_SENSOR_ORIENT_COMP_MAGN_NORTH,
465 			&st->rot_attributes.sensitivity);
466 		dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
467 			st->rot_attributes.sensitivity.index,
468 			st->rot_attributes.sensitivity.report_id);
469 	}
470 
471 	return 0;
472 }
473 
474 /* Function to initialize the processing for usage id */
hid_magn_3d_probe(struct platform_device * pdev)475 static int hid_magn_3d_probe(struct platform_device *pdev)
476 {
477 	int ret = 0;
478 	static char *name = "magn_3d";
479 	struct iio_dev *indio_dev;
480 	struct magn_3d_state *magn_state;
481 	struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
482 	struct iio_chan_spec *channels;
483 	int chan_count = 0;
484 
485 	indio_dev = devm_iio_device_alloc(&pdev->dev,
486 					  sizeof(struct magn_3d_state));
487 	if (indio_dev == NULL)
488 		return -ENOMEM;
489 
490 	platform_set_drvdata(pdev, indio_dev);
491 
492 	magn_state = iio_priv(indio_dev);
493 	magn_state->magn_flux_attributes.hsdev = hsdev;
494 	magn_state->magn_flux_attributes.pdev = pdev;
495 
496 	ret = hid_sensor_parse_common_attributes(hsdev,
497 				HID_USAGE_SENSOR_COMPASS_3D,
498 				&magn_state->magn_flux_attributes);
499 	if (ret) {
500 		dev_err(&pdev->dev, "failed to setup common attributes\n");
501 		return ret;
502 	}
503 	magn_state->rot_attributes = magn_state->magn_flux_attributes;
504 
505 	ret = magn_3d_parse_report(pdev, hsdev,
506 				&channels, &chan_count,
507 				HID_USAGE_SENSOR_COMPASS_3D, magn_state);
508 	if (ret) {
509 		dev_err(&pdev->dev, "failed to parse report\n");
510 		return ret;
511 	}
512 
513 	indio_dev->channels = channels;
514 	indio_dev->num_channels = chan_count;
515 	indio_dev->info = &magn_3d_info;
516 	indio_dev->name = name;
517 	indio_dev->modes = INDIO_DIRECT_MODE;
518 
519 	atomic_set(&magn_state->magn_flux_attributes.data_ready, 0);
520 
521 	ret = hid_sensor_setup_trigger(indio_dev, name,
522 					&magn_state->magn_flux_attributes);
523 	if (ret < 0) {
524 		dev_err(&pdev->dev, "trigger setup failed\n");
525 		return ret;
526 	}
527 
528 	ret = iio_device_register(indio_dev);
529 	if (ret) {
530 		dev_err(&pdev->dev, "device register failed\n");
531 		goto error_remove_trigger;
532 	}
533 
534 	magn_state->callbacks.send_event = magn_3d_proc_event;
535 	magn_state->callbacks.capture_sample = magn_3d_capture_sample;
536 	magn_state->callbacks.pdev = pdev;
537 	ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_COMPASS_3D,
538 					&magn_state->callbacks);
539 	if (ret < 0) {
540 		dev_err(&pdev->dev, "callback reg failed\n");
541 		goto error_iio_unreg;
542 	}
543 
544 	return ret;
545 
546 error_iio_unreg:
547 	iio_device_unregister(indio_dev);
548 error_remove_trigger:
549 	hid_sensor_remove_trigger(indio_dev, &magn_state->magn_flux_attributes);
550 	return ret;
551 }
552 
553 /* Function to deinitialize the processing for usage id */
hid_magn_3d_remove(struct platform_device * pdev)554 static int hid_magn_3d_remove(struct platform_device *pdev)
555 {
556 	struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
557 	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
558 	struct magn_3d_state *magn_state = iio_priv(indio_dev);
559 
560 	sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_COMPASS_3D);
561 	iio_device_unregister(indio_dev);
562 	hid_sensor_remove_trigger(indio_dev, &magn_state->magn_flux_attributes);
563 
564 	return 0;
565 }
566 
567 static const struct platform_device_id hid_magn_3d_ids[] = {
568 	{
569 		/* Format: HID-SENSOR-usage_id_in_hex_lowercase */
570 		.name = "HID-SENSOR-200083",
571 	},
572 	{ /* sentinel */ }
573 };
574 MODULE_DEVICE_TABLE(platform, hid_magn_3d_ids);
575 
576 static struct platform_driver hid_magn_3d_platform_driver = {
577 	.id_table = hid_magn_3d_ids,
578 	.driver = {
579 		.name	= KBUILD_MODNAME,
580 		.pm	= &hid_sensor_pm_ops,
581 	},
582 	.probe		= hid_magn_3d_probe,
583 	.remove		= hid_magn_3d_remove,
584 };
585 module_platform_driver(hid_magn_3d_platform_driver);
586 
587 MODULE_DESCRIPTION("HID Sensor Magnetometer 3D");
588 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
589 MODULE_LICENSE("GPL");
590