1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Device driver for the the HMC5843 multi-chip module designed
4  * for low field magnetic sensing.
5  *
6  * Copyright (C) 2010 Texas Instruments
7  *
8  * Author: Shubhrajyoti Datta <shubhrajyoti@ti.com>
9  * Acknowledgment: Jonathan Cameron <jic23@kernel.org> for valuable inputs.
10  * Support for HMC5883 and HMC5883L by Peter Meerwald <pmeerw@pmeerw.net>.
11  * Split to multiple files by Josef Gajdusek <atx@atx.name> - 2014
12  */
13 
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18 #include <linux/iio/trigger_consumer.h>
19 #include <linux/iio/buffer.h>
20 #include <linux/iio/triggered_buffer.h>
21 #include <linux/delay.h>
22 
23 #include "hmc5843.h"
24 
25 /*
26  * Range gain settings in (+-)Ga
27  * Beware: HMC5843 and HMC5883 have different recommended sensor field
28  * ranges; default corresponds to +-1.0 Ga and +-1.3 Ga, respectively
29  */
30 #define HMC5843_RANGE_GAIN_OFFSET		0x05
31 #define HMC5843_RANGE_GAIN_DEFAULT		0x01
32 #define HMC5843_RANGE_GAIN_MASK		0xe0
33 
34 /* Device status */
35 #define HMC5843_DATA_READY			0x01
36 #define HMC5843_DATA_OUTPUT_LOCK		0x02
37 
38 /* Mode register configuration */
39 #define HMC5843_MODE_CONVERSION_CONTINUOUS	0x00
40 #define HMC5843_MODE_CONVERSION_SINGLE		0x01
41 #define HMC5843_MODE_IDLE			0x02
42 #define HMC5843_MODE_SLEEP			0x03
43 #define HMC5843_MODE_MASK			0x03
44 
45 /*
46  * HMC5843: Minimum data output rate
47  * HMC5883: Typical data output rate
48  */
49 #define HMC5843_RATE_OFFSET			0x02
50 #define HMC5843_RATE_DEFAULT			0x04
51 #define HMC5843_RATE_MASK		0x1c
52 
53 /* Device measurement configuration */
54 #define HMC5843_MEAS_CONF_NORMAL		0x00
55 #define HMC5843_MEAS_CONF_POSITIVE_BIAS		0x01
56 #define HMC5843_MEAS_CONF_NEGATIVE_BIAS		0x02
57 #define HMC5843_MEAS_CONF_MASK			0x03
58 
59 /*
60  * API for setting the measurement configuration to
61  * Normal, Positive bias and Negative bias
62  *
63  * From the datasheet:
64  * 0 - Normal measurement configuration (default): In normal measurement
65  *     configuration the device follows normal measurement flow. Pins BP
66  *     and BN are left floating and high impedance.
67  *
68  * 1 - Positive bias configuration: In positive bias configuration, a
69  *     positive current is forced across the resistive load on pins BP
70  *     and BN.
71  *
72  * 2 - Negative bias configuration. In negative bias configuration, a
73  *     negative current is forced across the resistive load on pins BP
74  *     and BN.
75  *
76  * 3 - Only available on HMC5983. Magnetic sensor is disabled.
77  *     Temperature sensor is enabled.
78  */
79 
80 static const char *const hmc5843_meas_conf_modes[] = {"normal", "positivebias",
81 						      "negativebias"};
82 
83 static const char *const hmc5983_meas_conf_modes[] = {"normal", "positivebias",
84 						      "negativebias",
85 						      "disabled"};
86 /* Scaling factors: 10000000/Gain */
87 static const int hmc5843_regval_to_nanoscale[] = {
88 	6173, 7692, 10309, 12821, 18868, 21739, 25641, 35714
89 };
90 
91 static const int hmc5883_regval_to_nanoscale[] = {
92 	7812, 9766, 13021, 16287, 24096, 27701, 32573, 45662
93 };
94 
95 static const int hmc5883l_regval_to_nanoscale[] = {
96 	7299, 9174, 12195, 15152, 22727, 25641, 30303, 43478
97 };
98 
99 /*
100  * From the datasheet:
101  * Value	| HMC5843		| HMC5883/HMC5883L
102  *		| Data output rate (Hz)	| Data output rate (Hz)
103  * 0		| 0.5			| 0.75
104  * 1		| 1			| 1.5
105  * 2		| 2			| 3
106  * 3		| 5			| 7.5
107  * 4		| 10 (default)		| 15
108  * 5		| 20			| 30
109  * 6		| 50			| 75
110  * 7		| Not used		| Not used
111  */
112 static const int hmc5843_regval_to_samp_freq[][2] = {
113 	{0, 500000}, {1, 0}, {2, 0}, {5, 0}, {10, 0}, {20, 0}, {50, 0}
114 };
115 
116 static const int hmc5883_regval_to_samp_freq[][2] = {
117 	{0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
118 	{75, 0}
119 };
120 
121 static const int hmc5983_regval_to_samp_freq[][2] = {
122 	{0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
123 	{75, 0}, {220, 0}
124 };
125 
126 /* Describe chip variants */
127 struct hmc5843_chip_info {
128 	const struct iio_chan_spec *channels;
129 	const int (*regval_to_samp_freq)[2];
130 	const int n_regval_to_samp_freq;
131 	const int *regval_to_nanoscale;
132 	const int n_regval_to_nanoscale;
133 };
134 
135 /* The lower two bits contain the current conversion mode */
136 static s32 hmc5843_set_mode(struct hmc5843_data *data, u8 operating_mode)
137 {
138 	int ret;
139 
140 	mutex_lock(&data->lock);
141 	ret = regmap_update_bits(data->regmap, HMC5843_MODE_REG,
142 				 HMC5843_MODE_MASK, operating_mode);
143 	mutex_unlock(&data->lock);
144 
145 	return ret;
146 }
147 
148 static int hmc5843_wait_measurement(struct hmc5843_data *data)
149 {
150 	int tries = 150;
151 	unsigned int val;
152 	int ret;
153 
154 	while (tries-- > 0) {
155 		ret = regmap_read(data->regmap, HMC5843_STATUS_REG, &val);
156 		if (ret < 0)
157 			return ret;
158 		if (val & HMC5843_DATA_READY)
159 			break;
160 		msleep(20);
161 	}
162 
163 	if (tries < 0) {
164 		dev_err(data->dev, "data not ready\n");
165 		return -EIO;
166 	}
167 
168 	return 0;
169 }
170 
171 /* Return the measurement value from the specified channel */
172 static int hmc5843_read_measurement(struct hmc5843_data *data,
173 				    int idx, int *val)
174 {
175 	__be16 values[3];
176 	int ret;
177 
178 	mutex_lock(&data->lock);
179 	ret = hmc5843_wait_measurement(data);
180 	if (ret < 0) {
181 		mutex_unlock(&data->lock);
182 		return ret;
183 	}
184 	ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
185 			       values, sizeof(values));
186 	mutex_unlock(&data->lock);
187 	if (ret < 0)
188 		return ret;
189 
190 	*val = sign_extend32(be16_to_cpu(values[idx]), 15);
191 	return IIO_VAL_INT;
192 }
193 
194 static int hmc5843_set_meas_conf(struct hmc5843_data *data, u8 meas_conf)
195 {
196 	int ret;
197 
198 	mutex_lock(&data->lock);
199 	ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
200 				 HMC5843_MEAS_CONF_MASK, meas_conf);
201 	mutex_unlock(&data->lock);
202 
203 	return ret;
204 }
205 
206 static
207 int hmc5843_show_measurement_configuration(struct iio_dev *indio_dev,
208 					   const struct iio_chan_spec *chan)
209 {
210 	struct hmc5843_data *data = iio_priv(indio_dev);
211 	unsigned int val;
212 	int ret;
213 
214 	ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &val);
215 	if (ret)
216 		return ret;
217 
218 	return val & HMC5843_MEAS_CONF_MASK;
219 }
220 
221 static
222 int hmc5843_set_measurement_configuration(struct iio_dev *indio_dev,
223 					  const struct iio_chan_spec *chan,
224 					  unsigned int meas_conf)
225 {
226 	struct hmc5843_data *data = iio_priv(indio_dev);
227 
228 	return hmc5843_set_meas_conf(data, meas_conf);
229 }
230 
231 static const struct iio_mount_matrix *
232 hmc5843_get_mount_matrix(const struct iio_dev *indio_dev,
233 			  const struct iio_chan_spec *chan)
234 {
235 	struct hmc5843_data *data = iio_priv(indio_dev);
236 
237 	return &data->orientation;
238 }
239 
240 static const struct iio_enum hmc5843_meas_conf_enum = {
241 	.items = hmc5843_meas_conf_modes,
242 	.num_items = ARRAY_SIZE(hmc5843_meas_conf_modes),
243 	.get = hmc5843_show_measurement_configuration,
244 	.set = hmc5843_set_measurement_configuration,
245 };
246 
247 static const struct iio_chan_spec_ext_info hmc5843_ext_info[] = {
248 	IIO_ENUM("meas_conf", IIO_SHARED_BY_TYPE, &hmc5843_meas_conf_enum),
249 	IIO_ENUM_AVAILABLE("meas_conf", IIO_SHARED_BY_TYPE, &hmc5843_meas_conf_enum),
250 	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, hmc5843_get_mount_matrix),
251 	{ }
252 };
253 
254 static const struct iio_enum hmc5983_meas_conf_enum = {
255 	.items = hmc5983_meas_conf_modes,
256 	.num_items = ARRAY_SIZE(hmc5983_meas_conf_modes),
257 	.get = hmc5843_show_measurement_configuration,
258 	.set = hmc5843_set_measurement_configuration,
259 };
260 
261 static const struct iio_chan_spec_ext_info hmc5983_ext_info[] = {
262 	IIO_ENUM("meas_conf", IIO_SHARED_BY_TYPE, &hmc5983_meas_conf_enum),
263 	IIO_ENUM_AVAILABLE("meas_conf", IIO_SHARED_BY_TYPE, &hmc5983_meas_conf_enum),
264 	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, hmc5843_get_mount_matrix),
265 	{ }
266 };
267 
268 static
269 ssize_t hmc5843_show_samp_freq_avail(struct device *dev,
270 				     struct device_attribute *attr, char *buf)
271 {
272 	struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
273 	size_t len = 0;
274 	int i;
275 
276 	for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
277 		len += scnprintf(buf + len, PAGE_SIZE - len,
278 			"%d.%d ", data->variant->regval_to_samp_freq[i][0],
279 			data->variant->regval_to_samp_freq[i][1]);
280 
281 	/* replace trailing space by newline */
282 	buf[len - 1] = '\n';
283 
284 	return len;
285 }
286 
287 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hmc5843_show_samp_freq_avail);
288 
289 static int hmc5843_set_samp_freq(struct hmc5843_data *data, u8 rate)
290 {
291 	int ret;
292 
293 	mutex_lock(&data->lock);
294 	ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
295 				 HMC5843_RATE_MASK,
296 				 rate << HMC5843_RATE_OFFSET);
297 	mutex_unlock(&data->lock);
298 
299 	return ret;
300 }
301 
302 static int hmc5843_get_samp_freq_index(struct hmc5843_data *data,
303 				       int val, int val2)
304 {
305 	int i;
306 
307 	for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
308 		if (val == data->variant->regval_to_samp_freq[i][0] &&
309 		    val2 == data->variant->regval_to_samp_freq[i][1])
310 			return i;
311 
312 	return -EINVAL;
313 }
314 
315 static int hmc5843_set_range_gain(struct hmc5843_data *data, u8 range)
316 {
317 	int ret;
318 
319 	mutex_lock(&data->lock);
320 	ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_B,
321 				 HMC5843_RANGE_GAIN_MASK,
322 				 range << HMC5843_RANGE_GAIN_OFFSET);
323 	mutex_unlock(&data->lock);
324 
325 	return ret;
326 }
327 
328 static ssize_t hmc5843_show_scale_avail(struct device *dev,
329 					struct device_attribute *attr,
330 					char *buf)
331 {
332 	struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
333 
334 	size_t len = 0;
335 	int i;
336 
337 	for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
338 		len += scnprintf(buf + len, PAGE_SIZE - len,
339 			"0.%09d ", data->variant->regval_to_nanoscale[i]);
340 
341 	/* replace trailing space by newline */
342 	buf[len - 1] = '\n';
343 
344 	return len;
345 }
346 
347 static IIO_DEVICE_ATTR(scale_available, S_IRUGO,
348 	hmc5843_show_scale_avail, NULL, 0);
349 
350 static int hmc5843_get_scale_index(struct hmc5843_data *data, int val, int val2)
351 {
352 	int i;
353 
354 	if (val)
355 		return -EINVAL;
356 
357 	for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
358 		if (val2 == data->variant->regval_to_nanoscale[i])
359 			return i;
360 
361 	return -EINVAL;
362 }
363 
364 static int hmc5843_read_raw(struct iio_dev *indio_dev,
365 			    struct iio_chan_spec const *chan,
366 			    int *val, int *val2, long mask)
367 {
368 	struct hmc5843_data *data = iio_priv(indio_dev);
369 	unsigned int rval;
370 	int ret;
371 
372 	switch (mask) {
373 	case IIO_CHAN_INFO_RAW:
374 		return hmc5843_read_measurement(data, chan->scan_index, val);
375 	case IIO_CHAN_INFO_SCALE:
376 		ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_B, &rval);
377 		if (ret < 0)
378 			return ret;
379 		rval >>= HMC5843_RANGE_GAIN_OFFSET;
380 		*val = 0;
381 		*val2 = data->variant->regval_to_nanoscale[rval];
382 		return IIO_VAL_INT_PLUS_NANO;
383 	case IIO_CHAN_INFO_SAMP_FREQ:
384 		ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &rval);
385 		if (ret < 0)
386 			return ret;
387 		rval >>= HMC5843_RATE_OFFSET;
388 		*val = data->variant->regval_to_samp_freq[rval][0];
389 		*val2 = data->variant->regval_to_samp_freq[rval][1];
390 		return IIO_VAL_INT_PLUS_MICRO;
391 	}
392 	return -EINVAL;
393 }
394 
395 static int hmc5843_write_raw(struct iio_dev *indio_dev,
396 			     struct iio_chan_spec const *chan,
397 			     int val, int val2, long mask)
398 {
399 	struct hmc5843_data *data = iio_priv(indio_dev);
400 	int rate, range;
401 
402 	switch (mask) {
403 	case IIO_CHAN_INFO_SAMP_FREQ:
404 		rate = hmc5843_get_samp_freq_index(data, val, val2);
405 		if (rate < 0)
406 			return -EINVAL;
407 
408 		return hmc5843_set_samp_freq(data, rate);
409 	case IIO_CHAN_INFO_SCALE:
410 		range = hmc5843_get_scale_index(data, val, val2);
411 		if (range < 0)
412 			return -EINVAL;
413 
414 		return hmc5843_set_range_gain(data, range);
415 	default:
416 		return -EINVAL;
417 	}
418 }
419 
420 static int hmc5843_write_raw_get_fmt(struct iio_dev *indio_dev,
421 				     struct iio_chan_spec const *chan,
422 				     long mask)
423 {
424 	switch (mask) {
425 	case IIO_CHAN_INFO_SAMP_FREQ:
426 		return IIO_VAL_INT_PLUS_MICRO;
427 	case IIO_CHAN_INFO_SCALE:
428 		return IIO_VAL_INT_PLUS_NANO;
429 	default:
430 		return -EINVAL;
431 	}
432 }
433 
434 static irqreturn_t hmc5843_trigger_handler(int irq, void *p)
435 {
436 	struct iio_poll_func *pf = p;
437 	struct iio_dev *indio_dev = pf->indio_dev;
438 	struct hmc5843_data *data = iio_priv(indio_dev);
439 	int ret;
440 
441 	mutex_lock(&data->lock);
442 	ret = hmc5843_wait_measurement(data);
443 	if (ret < 0) {
444 		mutex_unlock(&data->lock);
445 		goto done;
446 	}
447 
448 	ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
449 			       data->scan.chans, sizeof(data->scan.chans));
450 
451 	mutex_unlock(&data->lock);
452 	if (ret < 0)
453 		goto done;
454 
455 	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
456 					   iio_get_time_ns(indio_dev));
457 
458 done:
459 	iio_trigger_notify_done(indio_dev->trig);
460 
461 	return IRQ_HANDLED;
462 }
463 
464 #define HMC5843_CHANNEL(axis, idx)					\
465 	{								\
466 		.type = IIO_MAGN,					\
467 		.modified = 1,						\
468 		.channel2 = IIO_MOD_##axis,				\
469 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
470 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |	\
471 			BIT(IIO_CHAN_INFO_SAMP_FREQ),			\
472 		.scan_index = idx,					\
473 		.scan_type = {						\
474 			.sign = 's',					\
475 			.realbits = 16,					\
476 			.storagebits = 16,				\
477 			.endianness = IIO_BE,				\
478 		},							\
479 		.ext_info = hmc5843_ext_info,	\
480 	}
481 
482 #define HMC5983_CHANNEL(axis, idx)					\
483 	{								\
484 		.type = IIO_MAGN,					\
485 		.modified = 1,						\
486 		.channel2 = IIO_MOD_##axis,				\
487 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
488 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |	\
489 			BIT(IIO_CHAN_INFO_SAMP_FREQ),			\
490 		.scan_index = idx,					\
491 		.scan_type = {						\
492 			.sign = 's',					\
493 			.realbits = 16,					\
494 			.storagebits = 16,				\
495 			.endianness = IIO_BE,				\
496 		},							\
497 		.ext_info = hmc5983_ext_info,	\
498 	}
499 
500 static const struct iio_chan_spec hmc5843_channels[] = {
501 	HMC5843_CHANNEL(X, 0),
502 	HMC5843_CHANNEL(Y, 1),
503 	HMC5843_CHANNEL(Z, 2),
504 	IIO_CHAN_SOFT_TIMESTAMP(3),
505 };
506 
507 /* Beware: Y and Z are exchanged on HMC5883 and 5983 */
508 static const struct iio_chan_spec hmc5883_channels[] = {
509 	HMC5843_CHANNEL(X, 0),
510 	HMC5843_CHANNEL(Z, 1),
511 	HMC5843_CHANNEL(Y, 2),
512 	IIO_CHAN_SOFT_TIMESTAMP(3),
513 };
514 
515 static const struct iio_chan_spec hmc5983_channels[] = {
516 	HMC5983_CHANNEL(X, 0),
517 	HMC5983_CHANNEL(Z, 1),
518 	HMC5983_CHANNEL(Y, 2),
519 	IIO_CHAN_SOFT_TIMESTAMP(3),
520 };
521 
522 static struct attribute *hmc5843_attributes[] = {
523 	&iio_dev_attr_scale_available.dev_attr.attr,
524 	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
525 	NULL
526 };
527 
528 static const struct attribute_group hmc5843_group = {
529 	.attrs = hmc5843_attributes,
530 };
531 
532 static const struct hmc5843_chip_info hmc5843_chip_info_tbl[] = {
533 	[HMC5843_ID] = {
534 		.channels = hmc5843_channels,
535 		.regval_to_samp_freq = hmc5843_regval_to_samp_freq,
536 		.n_regval_to_samp_freq =
537 				ARRAY_SIZE(hmc5843_regval_to_samp_freq),
538 		.regval_to_nanoscale = hmc5843_regval_to_nanoscale,
539 		.n_regval_to_nanoscale =
540 				ARRAY_SIZE(hmc5843_regval_to_nanoscale),
541 	},
542 	[HMC5883_ID] = {
543 		.channels = hmc5883_channels,
544 		.regval_to_samp_freq = hmc5883_regval_to_samp_freq,
545 		.n_regval_to_samp_freq =
546 				ARRAY_SIZE(hmc5883_regval_to_samp_freq),
547 		.regval_to_nanoscale = hmc5883_regval_to_nanoscale,
548 		.n_regval_to_nanoscale =
549 				ARRAY_SIZE(hmc5883_regval_to_nanoscale),
550 	},
551 	[HMC5883L_ID] = {
552 		.channels = hmc5883_channels,
553 		.regval_to_samp_freq = hmc5883_regval_to_samp_freq,
554 		.n_regval_to_samp_freq =
555 				ARRAY_SIZE(hmc5883_regval_to_samp_freq),
556 		.regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
557 		.n_regval_to_nanoscale =
558 				ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
559 	},
560 	[HMC5983_ID] = {
561 		.channels = hmc5983_channels,
562 		.regval_to_samp_freq = hmc5983_regval_to_samp_freq,
563 		.n_regval_to_samp_freq =
564 				ARRAY_SIZE(hmc5983_regval_to_samp_freq),
565 		.regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
566 		.n_regval_to_nanoscale =
567 				ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
568 	}
569 };
570 
571 static int hmc5843_init(struct hmc5843_data *data)
572 {
573 	int ret;
574 	u8 id[3];
575 
576 	ret = regmap_bulk_read(data->regmap, HMC5843_ID_REG,
577 			       id, ARRAY_SIZE(id));
578 	if (ret < 0)
579 		return ret;
580 	if (id[0] != 'H' || id[1] != '4' || id[2] != '3') {
581 		dev_err(data->dev, "no HMC5843/5883/5883L/5983 sensor\n");
582 		return -ENODEV;
583 	}
584 
585 	ret = hmc5843_set_meas_conf(data, HMC5843_MEAS_CONF_NORMAL);
586 	if (ret < 0)
587 		return ret;
588 	ret = hmc5843_set_samp_freq(data, HMC5843_RATE_DEFAULT);
589 	if (ret < 0)
590 		return ret;
591 	ret = hmc5843_set_range_gain(data, HMC5843_RANGE_GAIN_DEFAULT);
592 	if (ret < 0)
593 		return ret;
594 	return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS);
595 }
596 
597 static const struct iio_info hmc5843_info = {
598 	.attrs = &hmc5843_group,
599 	.read_raw = &hmc5843_read_raw,
600 	.write_raw = &hmc5843_write_raw,
601 	.write_raw_get_fmt = &hmc5843_write_raw_get_fmt,
602 };
603 
604 static const unsigned long hmc5843_scan_masks[] = {0x7, 0};
605 
606 int hmc5843_common_suspend(struct device *dev)
607 {
608 	return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
609 				HMC5843_MODE_SLEEP);
610 }
611 EXPORT_SYMBOL_NS(hmc5843_common_suspend, IIO_HMC5843);
612 
613 int hmc5843_common_resume(struct device *dev)
614 {
615 	return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
616 		HMC5843_MODE_CONVERSION_CONTINUOUS);
617 }
618 EXPORT_SYMBOL_NS(hmc5843_common_resume, IIO_HMC5843);
619 
620 int hmc5843_common_probe(struct device *dev, struct regmap *regmap,
621 			 enum hmc5843_ids id, const char *name)
622 {
623 	struct hmc5843_data *data;
624 	struct iio_dev *indio_dev;
625 	int ret;
626 
627 	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
628 	if (!indio_dev)
629 		return -ENOMEM;
630 
631 	dev_set_drvdata(dev, indio_dev);
632 
633 	/* default settings at probe */
634 	data = iio_priv(indio_dev);
635 	data->dev = dev;
636 	data->regmap = regmap;
637 	data->variant = &hmc5843_chip_info_tbl[id];
638 	mutex_init(&data->lock);
639 
640 	ret = iio_read_mount_matrix(dev, &data->orientation);
641 	if (ret)
642 		return ret;
643 
644 	indio_dev->name = name;
645 	indio_dev->info = &hmc5843_info;
646 	indio_dev->modes = INDIO_DIRECT_MODE;
647 	indio_dev->channels = data->variant->channels;
648 	indio_dev->num_channels = 4;
649 	indio_dev->available_scan_masks = hmc5843_scan_masks;
650 
651 	ret = hmc5843_init(data);
652 	if (ret < 0)
653 		return ret;
654 
655 	ret = iio_triggered_buffer_setup(indio_dev, NULL,
656 					 hmc5843_trigger_handler, NULL);
657 	if (ret < 0)
658 		goto buffer_setup_err;
659 
660 	ret = iio_device_register(indio_dev);
661 	if (ret < 0)
662 		goto buffer_cleanup;
663 
664 	return 0;
665 
666 buffer_cleanup:
667 	iio_triggered_buffer_cleanup(indio_dev);
668 buffer_setup_err:
669 	hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
670 	return ret;
671 }
672 EXPORT_SYMBOL_NS(hmc5843_common_probe, IIO_HMC5843);
673 
674 void hmc5843_common_remove(struct device *dev)
675 {
676 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
677 
678 	iio_device_unregister(indio_dev);
679 	iio_triggered_buffer_cleanup(indio_dev);
680 
681 	/*  sleep mode to save power */
682 	hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
683 }
684 EXPORT_SYMBOL_NS(hmc5843_common_remove, IIO_HMC5843);
685 
686 MODULE_AUTHOR("Shubhrajyoti Datta <shubhrajyoti@ti.com>");
687 MODULE_DESCRIPTION("HMC5843/5883/5883L/5983 core driver");
688 MODULE_LICENSE("GPL");
689