tmag5273.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Driver for the TI TMAG5273 Low-Power Linear 3D Hall-Effect Sensor
  4 *
  5 * Copyright (C) 2022 WolfVision GmbH
  6 *
  7 * Author: Gerald Loacker <gerald.loacker@wolfvision.net>
  8 */
  9
 10#include <linux/bitfield.h>
 11#include <linux/bits.h>
 12#include <linux/delay.h>
 13#include <linux/module.h>
 14#include <linux/i2c.h>
 15#include <linux/regmap.h>
 16#include <linux/pm_runtime.h>
 17
 18#include <linux/iio/iio.h>
 19#include <linux/iio/sysfs.h>
 20
 21#define TMAG5273_DEVICE_CONFIG_1	 0x00
 22#define TMAG5273_DEVICE_CONFIG_2	 0x01
 23#define TMAG5273_SENSOR_CONFIG_1	 0x02
 24#define TMAG5273_SENSOR_CONFIG_2	 0x03
 25#define TMAG5273_X_THR_CONFIG		 0x04
 26#define TMAG5273_Y_THR_CONFIG		 0x05
 27#define TMAG5273_Z_THR_CONFIG		 0x06
 28#define TMAG5273_T_CONFIG		 0x07
 29#define TMAG5273_INT_CONFIG_1		 0x08
 30#define TMAG5273_MAG_GAIN_CONFIG	 0x09
 31#define TMAG5273_MAG_OFFSET_CONFIG_1	 0x0A
 32#define TMAG5273_MAG_OFFSET_CONFIG_2	 0x0B
 33#define TMAG5273_I2C_ADDRESS		 0x0C
 34#define TMAG5273_DEVICE_ID		 0x0D
 35#define TMAG5273_MANUFACTURER_ID_LSB	 0x0E
 36#define TMAG5273_MANUFACTURER_ID_MSB	 0x0F
 37#define TMAG5273_T_MSB_RESULT		 0x10
 38#define TMAG5273_T_LSB_RESULT		 0x11
 39#define TMAG5273_X_MSB_RESULT		 0x12
 40#define TMAG5273_X_LSB_RESULT		 0x13
 41#define TMAG5273_Y_MSB_RESULT		 0x14
 42#define TMAG5273_Y_LSB_RESULT		 0x15
 43#define TMAG5273_Z_MSB_RESULT		 0x16
 44#define TMAG5273_Z_LSB_RESULT		 0x17
 45#define TMAG5273_CONV_STATUS		 0x18
 46#define TMAG5273_ANGLE_RESULT_MSB	 0x19
 47#define TMAG5273_ANGLE_RESULT_LSB	 0x1A
 48#define TMAG5273_MAGNITUDE_RESULT	 0x1B
 49#define TMAG5273_DEVICE_STATUS		 0x1C
 50#define TMAG5273_MAX_REG		 TMAG5273_DEVICE_STATUS
 51
 52#define TMAG5273_AUTOSLEEP_DELAY_MS	 5000
 53#define TMAG5273_MAX_AVERAGE             32
 54
 55/*
 56 * bits in the TMAG5273_MANUFACTURER_ID_LSB / MSB register
 57 * 16-bit unique manufacturer ID 0x49 / 0x54 = "TI"
 58 */
 59#define TMAG5273_MANUFACTURER_ID	 0x5449
 60
 61/* bits in the TMAG5273_DEVICE_CONFIG_1 register */
 62#define TMAG5273_AVG_MODE_MASK		 GENMASK(4, 2)
 63#define TMAG5273_AVG_1_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 0)
 64#define TMAG5273_AVG_2_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 1)
 65#define TMAG5273_AVG_4_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 2)
 66#define TMAG5273_AVG_8_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 3)
 67#define TMAG5273_AVG_16_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 4)
 68#define TMAG5273_AVG_32_MODE		 FIELD_PREP(TMAG5273_AVG_MODE_MASK, 5)
 69
 70/* bits in the TMAG5273_DEVICE_CONFIG_2 register */
 71#define TMAG5273_OP_MODE_MASK		 GENMASK(1, 0)
 72#define TMAG5273_OP_MODE_STANDBY	 FIELD_PREP(TMAG5273_OP_MODE_MASK, 0)
 73#define TMAG5273_OP_MODE_SLEEP		 FIELD_PREP(TMAG5273_OP_MODE_MASK, 1)
 74#define TMAG5273_OP_MODE_CONT		 FIELD_PREP(TMAG5273_OP_MODE_MASK, 2)
 75#define TMAG5273_OP_MODE_WAKEUP		 FIELD_PREP(TMAG5273_OP_MODE_MASK, 3)
 76
 77/* bits in the TMAG5273_SENSOR_CONFIG_1 register */
 78#define TMAG5273_MAG_CH_EN_MASK		 GENMASK(7, 4)
 79#define TMAG5273_MAG_CH_EN_X_Y_Z	 7
 80
 81/* bits in the TMAG5273_SENSOR_CONFIG_2 register */
 82#define TMAG5273_Z_RANGE_MASK		 BIT(0)
 83#define TMAG5273_X_Y_RANGE_MASK		 BIT(1)
 84#define TMAG5273_ANGLE_EN_MASK		 GENMASK(3, 2)
 85#define TMAG5273_ANGLE_EN_OFF		 0
 86#define TMAG5273_ANGLE_EN_X_Y		 1
 87#define TMAG5273_ANGLE_EN_Y_Z		 2
 88#define TMAG5273_ANGLE_EN_X_Z		 3
 89
 90/* bits in the TMAG5273_T_CONFIG register */
 91#define TMAG5273_T_CH_EN		 BIT(0)
 92
 93/* bits in the TMAG5273_DEVICE_ID register */
 94#define TMAG5273_VERSION_MASK		 GENMASK(1, 0)
 95
 96/* bits in the TMAG5273_CONV_STATUS register */
 97#define TMAG5273_CONV_STATUS_COMPLETE	 BIT(0)
 98
 99enum tmag5273_channels {
100	TEMPERATURE = 0,
101	AXIS_X,
102	AXIS_Y,
103	AXIS_Z,
104	ANGLE,
105	MAGNITUDE,
106};
107
108enum tmag5273_scale_index {
109	MAGN_RANGE_LOW = 0,
110	MAGN_RANGE_HIGH,
111	MAGN_RANGE_NUM
112};
113
114/* state container for the TMAG5273 driver */
115struct tmag5273_data {
116	struct device *dev;
117	unsigned int devid;
118	unsigned int version;
119	char name[16];
120	unsigned int conv_avg;
121	enum tmag5273_scale_index scale_index;
122	unsigned int angle_measurement;
123	struct regmap *map;
124
125	/*
126	 * Locks the sensor for exclusive use during a measurement (which
127	 * involves several register transactions so the regmap lock is not
128	 * enough) so that measurements get serialized in a
129	 * first-come-first-serve manner.
130	 */
131	struct mutex lock;
132};
133
134static const char *const tmag5273_angle_names[] = { "off", "x-y", "y-z", "x-z" };
135
136/*
137 * Averaging enables additional sampling of the sensor data to reduce the noise
138 * effect, but also increases conversion time.
139 */
140static const unsigned int tmag5273_avg_table[] = {
141	1, 2, 4, 8, 16, 32,
142};
143
144/*
145 * Magnetic resolution in Gauss for different TMAG5273 versions.
146 * Scale[Gauss] = Range[mT] * 1000 / 2^15 * 10, (1 mT = 10 Gauss)
147 * Only version 1 and 2 are valid, version 0 and 3 are reserved.
148 */
149static const struct iio_val_int_plus_micro tmag5273_scale[][MAGN_RANGE_NUM] = {
150	{ { 0,     0 }, { 0,     0 } },
151	{ { 0, 12200 }, { 0, 24400 } },
152	{ { 0, 40600 }, { 0, 81200 } },
153	{ { 0,     0 }, { 0,     0 } },
154};
155
156static int tmag5273_get_measure(struct tmag5273_data *data, s16 *t, s16 *x,
157				s16 *y, s16 *z, u16 *angle, u16 *magnitude)
158{
159	unsigned int status, val;
160	__be16 reg_data[4];
161	int ret;
162
163	mutex_lock(&data->lock);
164
165	/*
166	 * Max. conversion time is 2425 us in 32x averaging mode for all three
167	 * channels. Since we are in continuous measurement mode, a measurement
168	 * may already be there, so poll for completed measurement with
169	 * timeout.
170	 */
171	ret = regmap_read_poll_timeout(data->map, TMAG5273_CONV_STATUS, status,
172				       status & TMAG5273_CONV_STATUS_COMPLETE,
173				       100, 10000);
174	if (ret) {
175		dev_err(data->dev, "timeout waiting for measurement\n");
176		goto out_unlock;
177	}
178
179	ret = regmap_bulk_read(data->map, TMAG5273_T_MSB_RESULT, reg_data,
180			       sizeof(reg_data));
181	if (ret)
182		goto out_unlock;
183	*t = be16_to_cpu(reg_data[0]);
184	*x = be16_to_cpu(reg_data[1]);
185	*y = be16_to_cpu(reg_data[2]);
186	*z = be16_to_cpu(reg_data[3]);
187
188	ret = regmap_bulk_read(data->map, TMAG5273_ANGLE_RESULT_MSB,
189			       &reg_data[0], sizeof(reg_data[0]));
190	if (ret)
191		goto out_unlock;
192	/*
193	 * angle has 9 bits integer value and 4 bits fractional part
194	 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
195	 * 0  0  0  a  a  a  a  a  a  a  a  a  f  f  f  f
196	 */
197	*angle = be16_to_cpu(reg_data[0]);
198
199	ret = regmap_read(data->map, TMAG5273_MAGNITUDE_RESULT, &val);
200	if (ret < 0)
201		goto out_unlock;
202	*magnitude = val;
203
204out_unlock:
205	mutex_unlock(&data->lock);
206	return ret;
207}
208
209static int tmag5273_write_osr(struct tmag5273_data *data, int val)
210{
211	int i;
212
213	if (val == data->conv_avg)
214		return 0;
215
216	for (i = 0; i < ARRAY_SIZE(tmag5273_avg_table); i++) {
217		if (tmag5273_avg_table[i] == val)
218			break;
219	}
220	if (i == ARRAY_SIZE(tmag5273_avg_table))
221		return -EINVAL;
222	data->conv_avg = val;
223
224	return regmap_update_bits(data->map, TMAG5273_DEVICE_CONFIG_1,
225				  TMAG5273_AVG_MODE_MASK,
226				  FIELD_PREP(TMAG5273_AVG_MODE_MASK, i));
227}
228
229static int tmag5273_write_scale(struct tmag5273_data *data, int scale_micro)
230{
231	u32 value;
232	int i;
233
234	for (i = 0; i < ARRAY_SIZE(tmag5273_scale[0]); i++) {
235		if (tmag5273_scale[data->version][i].micro == scale_micro)
236			break;
237	}
238	if (i == ARRAY_SIZE(tmag5273_scale[0]))
239		return -EINVAL;
240	data->scale_index = i;
241
242	if (data->scale_index == MAGN_RANGE_LOW)
243		value = 0;
244	else
245		value = TMAG5273_Z_RANGE_MASK | TMAG5273_X_Y_RANGE_MASK;
246
247	return regmap_update_bits(data->map, TMAG5273_SENSOR_CONFIG_2,
248				  TMAG5273_Z_RANGE_MASK | TMAG5273_X_Y_RANGE_MASK, value);
249}
250
251static int tmag5273_read_avail(struct iio_dev *indio_dev,
252			       struct iio_chan_spec const *chan,
253			       const int **vals, int *type, int *length,
254			       long mask)
255{
256	struct tmag5273_data *data = iio_priv(indio_dev);
257
258	switch (mask) {
259	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
260		*vals = tmag5273_avg_table;
261		*type = IIO_VAL_INT;
262		*length = ARRAY_SIZE(tmag5273_avg_table);
263		return IIO_AVAIL_LIST;
264	case IIO_CHAN_INFO_SCALE:
265		switch (chan->type) {
266		case IIO_MAGN:
267			*type = IIO_VAL_INT_PLUS_MICRO;
268			*vals = (int *)tmag5273_scale[data->version];
269			*length = ARRAY_SIZE(tmag5273_scale[data->version]) *
270				  MAGN_RANGE_NUM;
271			return IIO_AVAIL_LIST;
272		default:
273			return -EINVAL;
274		}
275	default:
276		return -EINVAL;
277	}
278}
279
280static int tmag5273_read_raw(struct iio_dev *indio_dev,
281			     const struct iio_chan_spec *chan, int *val,
282			     int *val2, long mask)
283{
284	struct tmag5273_data *data = iio_priv(indio_dev);
285	s16 t, x, y, z;
286	u16 angle, magnitude;
287	int ret;
288
289	switch (mask) {
290	case IIO_CHAN_INFO_RAW:
291		ret = pm_runtime_resume_and_get(data->dev);
292		if (ret < 0)
293			return ret;
294
295		ret = tmag5273_get_measure(data, &t, &x, &y, &z, &angle, &magnitude);
296
297		pm_runtime_put_autosuspend(data->dev);
298
299		if (ret)
300			return ret;
301
302		switch (chan->address) {
303		case TEMPERATURE:
304			*val = t;
305			return IIO_VAL_INT;
306		case AXIS_X:
307			*val = x;
308			return IIO_VAL_INT;
309		case AXIS_Y:
310			*val = y;
311			return IIO_VAL_INT;
312		case AXIS_Z:
313			*val = z;
314			return IIO_VAL_INT;
315		case ANGLE:
316			*val = angle;
317			return IIO_VAL_INT;
318		case MAGNITUDE:
319			*val = magnitude;
320			return IIO_VAL_INT;
321		default:
322			return -EINVAL;
323		}
324	case IIO_CHAN_INFO_SCALE:
325		switch (chan->type) {
326		case IIO_TEMP:
327			/*
328			 * Convert device specific value to millicelsius.
329			 * Resolution from the sensor is 60.1 LSB/celsius and
330			 * the reference value at 25 celsius is 17508 LSBs.
331			 */
332			*val = 10000;
333			*val2 = 601;
334			return IIO_VAL_FRACTIONAL;
335		case IIO_MAGN:
336			/* Magnetic resolution in uT */
337			*val = 0;
338			*val2 = tmag5273_scale[data->version]
339					      [data->scale_index].micro;
340			return IIO_VAL_INT_PLUS_MICRO;
341		case IIO_ANGL:
342			/*
343			 * Angle is in degrees and has four fractional bits,
344			 * therefore use 1/16 * pi/180 to convert to radians.
345			 */
346			*val = 1000;
347			*val2 = 916732;
348			return IIO_VAL_FRACTIONAL;
349		default:
350			return -EINVAL;
351		}
352	case IIO_CHAN_INFO_OFFSET:
353		switch (chan->type) {
354		case IIO_TEMP:
355			*val = -16005;
356			return IIO_VAL_INT;
357		default:
358			return -EINVAL;
359		}
360	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
361		*val = data->conv_avg;
362		return IIO_VAL_INT;
363
364	default:
365		return -EINVAL;
366	}
367}
368
369static int tmag5273_write_raw(struct iio_dev *indio_dev,
370			      struct iio_chan_spec const *chan, int val,
371			      int val2, long mask)
372{
373	struct tmag5273_data *data = iio_priv(indio_dev);
374
375	switch (mask) {
376	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
377		return tmag5273_write_osr(data, val);
378	case IIO_CHAN_INFO_SCALE:
379		switch (chan->type) {
380		case IIO_MAGN:
381			if (val)
382				return -EINVAL;
383			return tmag5273_write_scale(data, val2);
384		default:
385			return -EINVAL;
386		}
387	default:
388		return -EINVAL;
389	}
390}
391
392#define TMAG5273_AXIS_CHANNEL(axis, index)				     \
393	{								     \
394		.type = IIO_MAGN,					     \
395		.modified = 1,						     \
396		.channel2 = IIO_MOD_##axis,				     \
397		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		     \
398				      BIT(IIO_CHAN_INFO_SCALE),		     \
399		.info_mask_shared_by_type_available =			     \
400				      BIT(IIO_CHAN_INFO_SCALE),		     \
401		.info_mask_shared_by_all =				     \
402				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
403		.info_mask_shared_by_all_available =			     \
404				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
405		.address = index,					     \
406		.scan_index = index,					     \
407		.scan_type = {						     \
408			.sign = 's',					     \
409			.realbits = 16,					     \
410			.storagebits = 16,				     \
411			.endianness = IIO_CPU,				     \
412		},							     \
413	}
414
415static const struct iio_chan_spec tmag5273_channels[] = {
416	{
417		.type = IIO_TEMP,
418		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
419			BIT(IIO_CHAN_INFO_SCALE) |
420			BIT(IIO_CHAN_INFO_OFFSET),
421		.address = TEMPERATURE,
422		.scan_index = TEMPERATURE,
423		.scan_type = {
424			.sign = 'u',
425			.realbits = 16,
426			.storagebits = 16,
427			.endianness = IIO_CPU,
428		},
429	},
430	TMAG5273_AXIS_CHANNEL(X, AXIS_X),
431	TMAG5273_AXIS_CHANNEL(Y, AXIS_Y),
432	TMAG5273_AXIS_CHANNEL(Z, AXIS_Z),
433	{
434		.type = IIO_ANGL,
435		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
436		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
437		.info_mask_shared_by_all =
438				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
439		.info_mask_shared_by_all_available =
440				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
441		.address = ANGLE,
442		.scan_index = ANGLE,
443		.scan_type = {
444			.sign = 'u',
445			.realbits = 16,
446			.storagebits = 16,
447			.endianness = IIO_CPU,
448		},
449	},
450	{
451		.type = IIO_DISTANCE,
452		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
453		.info_mask_shared_by_all =
454				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
455		.info_mask_shared_by_all_available =
456				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
457		.address = MAGNITUDE,
458		.scan_index = MAGNITUDE,
459		.scan_type = {
460			.sign = 'u',
461			.realbits = 16,
462			.storagebits = 16,
463			.endianness = IIO_CPU,
464		},
465	},
466	IIO_CHAN_SOFT_TIMESTAMP(6),
467};
468
469static const struct iio_info tmag5273_info = {
470	.read_avail = tmag5273_read_avail,
471	.read_raw = tmag5273_read_raw,
472	.write_raw = tmag5273_write_raw,
473};
474
475static bool tmag5273_volatile_reg(struct device *dev, unsigned int reg)
476{
477	return reg >= TMAG5273_T_MSB_RESULT && reg <= TMAG5273_MAGNITUDE_RESULT;
478}
479
480static const struct regmap_config tmag5273_regmap_config = {
481	.reg_bits = 8,
482	.val_bits = 8,
483	.max_register = TMAG5273_MAX_REG,
484	.volatile_reg = tmag5273_volatile_reg,
485};
486
487static int tmag5273_set_operating_mode(struct tmag5273_data *data,
488				       unsigned int val)
489{
490	return regmap_write(data->map, TMAG5273_DEVICE_CONFIG_2, val);
491}
492
493static void tmag5273_read_device_property(struct tmag5273_data *data)
494{
495	struct device *dev = data->dev;
496	int ret;
497
498	data->angle_measurement = TMAG5273_ANGLE_EN_X_Y;
499
500	ret = device_property_match_property_string(dev, "ti,angle-measurement",
501						    tmag5273_angle_names,
502						    ARRAY_SIZE(tmag5273_angle_names));
503	if (ret >= 0)
504		data->angle_measurement = ret;
505}
506
507static void tmag5273_wake_up(struct tmag5273_data *data)
508{
509	int val;
510
511	/* Wake up the chip by sending a dummy I2C command */
512	regmap_read(data->map, TMAG5273_DEVICE_ID, &val);
513	/*
514	 * Time to go to stand-by mode from sleep mode is 50us
515	 * typically, during this time no I2C access is possible.
516	 */
517	usleep_range(80, 200);
518}
519
520static int tmag5273_chip_init(struct tmag5273_data *data)
521{
522	int ret;
523
524	ret = regmap_write(data->map, TMAG5273_DEVICE_CONFIG_1,
525			   TMAG5273_AVG_32_MODE);
526	if (ret)
527		return ret;
528	data->conv_avg = 32;
529
530	ret = regmap_write(data->map, TMAG5273_DEVICE_CONFIG_2,
531			   TMAG5273_OP_MODE_CONT);
532	if (ret)
533		return ret;
534
535	ret = regmap_write(data->map, TMAG5273_SENSOR_CONFIG_1,
536			   FIELD_PREP(TMAG5273_MAG_CH_EN_MASK,
537				      TMAG5273_MAG_CH_EN_X_Y_Z));
538	if (ret)
539		return ret;
540
541	ret = regmap_write(data->map, TMAG5273_SENSOR_CONFIG_2,
542			   FIELD_PREP(TMAG5273_ANGLE_EN_MASK,
543				      data->angle_measurement));
544	if (ret)
545		return ret;
546	data->scale_index = MAGN_RANGE_LOW;
547
548	return regmap_write(data->map, TMAG5273_T_CONFIG, TMAG5273_T_CH_EN);
549}
550
551static int tmag5273_check_device_id(struct tmag5273_data *data)
552{
553	__le16 devid;
554	int val, ret;
555
556	ret = regmap_read(data->map, TMAG5273_DEVICE_ID, &val);
557	if (ret)
558		return dev_err_probe(data->dev, ret, "failed to power on device\n");
559	data->version = FIELD_PREP(TMAG5273_VERSION_MASK, val);
560
561	ret = regmap_bulk_read(data->map, TMAG5273_MANUFACTURER_ID_LSB, &devid,
562			       sizeof(devid));
563	if (ret)
564		return dev_err_probe(data->dev, ret, "failed to read device ID\n");
565	data->devid = le16_to_cpu(devid);
566
567	switch (data->devid) {
568	case TMAG5273_MANUFACTURER_ID:
569		/*
570		 * The device name matches the orderable part number. 'x' stands
571		 * for A, B, C or D devices, which have different I2C addresses.
572		 * Versions 1 or 2 (0 and 3 is reserved) stands for different
573		 * magnetic strengths.
574		 */
575		snprintf(data->name, sizeof(data->name), "tmag5273x%1u", data->version);
576		if (data->version < 1 || data->version > 2)
577			dev_warn(data->dev, "Unsupported device %s\n", data->name);
578		return 0;
579	default:
580		/*
581		 * Only print warning in case of unknown device ID to allow
582		 * fallback compatible in device tree.
583		 */
584		dev_warn(data->dev, "Unknown device ID 0x%x\n", data->devid);
585		return 0;
586	}
587}
588
589static void tmag5273_power_down(void *data)
590{
591	tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_SLEEP);
592}
593
594static int tmag5273_probe(struct i2c_client *i2c)
595{
596	struct device *dev = &i2c->dev;
597	struct tmag5273_data *data;
598	struct iio_dev *indio_dev;
599	int ret;
600
601	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
602	if (!indio_dev)
603		return -ENOMEM;
604
605	data = iio_priv(indio_dev);
606	data->dev = dev;
607	i2c_set_clientdata(i2c, indio_dev);
608
609	data->map = devm_regmap_init_i2c(i2c, &tmag5273_regmap_config);
610	if (IS_ERR(data->map))
611		return dev_err_probe(dev, PTR_ERR(data->map),
612				     "failed to allocate register map\n");
613
614	mutex_init(&data->lock);
615
616	ret = devm_regulator_get_enable(dev, "vcc");
617	if (ret)
618		return dev_err_probe(dev, ret, "failed to enable regulator\n");
619
620	tmag5273_wake_up(data);
621
622	ret = tmag5273_check_device_id(data);
623	if (ret)
624		return ret;
625
626	ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_CONT);
627	if (ret)
628		return dev_err_probe(dev, ret, "failed to power on device\n");
629
630	/*
631	 * Register powerdown deferred callback which suspends the chip
632	 * after module unloaded.
633	 *
634	 * TMAG5273 should be in SUSPEND mode in the two cases:
635	 * 1) When driver is loaded, but we do not have any data or
636	 *    configuration requests to it (we are solving it using
637	 *    autosuspend feature).
638	 * 2) When driver is unloaded and device is not used (devm action is
639	 *    used in this case).
640	 */
641	ret = devm_add_action_or_reset(dev, tmag5273_power_down, data);
642	if (ret)
643		return ret;
644
645	ret = pm_runtime_set_active(dev);
646	if (ret < 0)
647		return ret;
648
649	ret = devm_pm_runtime_enable(dev);
650	if (ret)
651		return ret;
652
653	pm_runtime_get_noresume(dev);
654	pm_runtime_set_autosuspend_delay(dev, TMAG5273_AUTOSLEEP_DELAY_MS);
655	pm_runtime_use_autosuspend(dev);
656
657	tmag5273_read_device_property(data);
658
659	ret = tmag5273_chip_init(data);
660	if (ret)
661		return dev_err_probe(dev, ret, "failed to init device\n");
662
663	indio_dev->info = &tmag5273_info;
664	indio_dev->modes = INDIO_DIRECT_MODE;
665	indio_dev->name = data->name;
666	indio_dev->channels = tmag5273_channels;
667	indio_dev->num_channels = ARRAY_SIZE(tmag5273_channels);
668
669	pm_runtime_put_autosuspend(dev);
670
671	ret = devm_iio_device_register(dev, indio_dev);
672	if (ret)
673		return dev_err_probe(dev, ret, "device register failed\n");
674
675	return 0;
676}
677
678static int tmag5273_runtime_suspend(struct device *dev)
679{
680	struct iio_dev *indio_dev = dev_get_drvdata(dev);
681	struct tmag5273_data *data = iio_priv(indio_dev);
682	int ret;
683
684	ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_SLEEP);
685	if (ret)
686		dev_err(dev, "failed to power off device (%pe)\n", ERR_PTR(ret));
687
688	return ret;
689}
690
691static int tmag5273_runtime_resume(struct device *dev)
692{
693	struct iio_dev *indio_dev = dev_get_drvdata(dev);
694	struct tmag5273_data *data = iio_priv(indio_dev);
695	int ret;
696
697	tmag5273_wake_up(data);
698
699	ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_CONT);
700	if (ret)
701		dev_err(dev, "failed to power on device (%pe)\n", ERR_PTR(ret));
702
703	return ret;
704}
705
706static DEFINE_RUNTIME_DEV_PM_OPS(tmag5273_pm_ops,
707				 tmag5273_runtime_suspend, tmag5273_runtime_resume,
708				 NULL);
709
710static const struct i2c_device_id tmag5273_id[] = {
711	{ "tmag5273" },
712	{ }
713};
714MODULE_DEVICE_TABLE(i2c, tmag5273_id);
715
716static const struct of_device_id tmag5273_of_match[] = {
717	{ .compatible = "ti,tmag5273" },
718	{ }
719};
720MODULE_DEVICE_TABLE(of, tmag5273_of_match);
721
722static struct i2c_driver tmag5273_driver = {
723	.driver	 = {
724		.name = "tmag5273",
725		.of_match_table = tmag5273_of_match,
726		.pm = pm_ptr(&tmag5273_pm_ops),
727	},
728	.probe = tmag5273_probe,
729	.id_table = tmag5273_id,
730};
731module_i2c_driver(tmag5273_driver);
732
733MODULE_DESCRIPTION("TI TMAG5273 Low-Power Linear 3D Hall-Effect Sensor driver");
734MODULE_AUTHOR("Gerald Loacker <gerald.loacker@wolfvision.net>");
735MODULE_LICENSE("GPL");