1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for the Yamaha YAS magnetic sensors, often used in Samsung
4  * mobile phones. While all are not yet handled because of lacking
5  * hardware, expand this driver to handle the different variants:
6  *
7  * YAS530 MS-3E (2011 Samsung Galaxy S Advance)
8  * YAS532 MS-3R (2011 Samsung Galaxy S4)
9  * YAS533 MS-3F (Vivo 1633, 1707, V3, Y21L)
10  * (YAS534 is a magnetic switch, not handled)
11  * YAS535 MS-6C
12  * YAS536 MS-3W
13  * YAS537 MS-3T (2015 Samsung Galaxy S6, Note 5, Xiaomi)
14  * YAS539 MS-3S (2018 Samsung Galaxy A7 SM-A750FN)
15  *
16  * Code functions found in the MPU3050 YAS530 and YAS532 drivers
17  * named "inv_compass" in the Tegra Android kernel tree.
18  * Copyright (C) 2012 InvenSense Corporation
19  *
20  * Author: Linus Walleij <linus.walleij@linaro.org>
21  */
22 #include <linux/bitfield.h>
23 #include <linux/bitops.h>
24 #include <linux/delay.h>
25 #include <linux/err.h>
26 #include <linux/gpio/consumer.h>
27 #include <linux/i2c.h>
28 #include <linux/module.h>
29 #include <linux/mod_devicetable.h>
30 #include <linux/mutex.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/regmap.h>
33 #include <linux/regulator/consumer.h>
34 #include <linux/random.h>
35 
36 #include <linux/iio/buffer.h>
37 #include <linux/iio/iio.h>
38 #include <linux/iio/trigger_consumer.h>
39 #include <linux/iio/triggered_buffer.h>
40 
41 #include <asm/unaligned.h>
42 
43 /* This register map covers YAS530 and YAS532 but differs in YAS 537 and YAS539 */
44 #define YAS5XX_DEVICE_ID		0x80
45 #define YAS5XX_ACTUATE_INIT_COIL	0x81
46 #define YAS5XX_MEASURE			0x82
47 #define YAS5XX_CONFIG			0x83
48 #define YAS5XX_MEASURE_INTERVAL		0x84
49 #define YAS5XX_OFFSET_X			0x85 /* [-31 .. 31] */
50 #define YAS5XX_OFFSET_Y1		0x86 /* [-31 .. 31] */
51 #define YAS5XX_OFFSET_Y2		0x87 /* [-31 .. 31] */
52 #define YAS5XX_TEST1			0x88
53 #define YAS5XX_TEST2			0x89
54 #define YAS5XX_CAL			0x90
55 #define YAS5XX_MEASURE_DATA		0xB0
56 
57 /* Bits in the YAS5xx config register */
58 #define YAS5XX_CONFIG_INTON		BIT(0) /* Interrupt on? */
59 #define YAS5XX_CONFIG_INTHACT		BIT(1) /* Interrupt active high? */
60 #define YAS5XX_CONFIG_CCK_MASK		GENMASK(4, 2)
61 #define YAS5XX_CONFIG_CCK_SHIFT		2
62 
63 /* Bits in the measure command register */
64 #define YAS5XX_MEASURE_START		BIT(0)
65 #define YAS5XX_MEASURE_LDTC		BIT(1)
66 #define YAS5XX_MEASURE_FORS		BIT(2)
67 #define YAS5XX_MEASURE_DLYMES		BIT(4)
68 
69 /* Bits in the measure data register */
70 #define YAS5XX_MEASURE_DATA_BUSY	BIT(7)
71 
72 #define YAS530_DEVICE_ID		0x01 /* YAS530 (MS-3E) */
73 #define YAS530_VERSION_A		0 /* YAS530 (MS-3E A) */
74 #define YAS530_VERSION_B		1 /* YAS530B (MS-3E B) */
75 #define YAS530_VERSION_A_COEF		380
76 #define YAS530_VERSION_B_COEF		550
77 #define YAS530_DATA_BITS		12
78 #define YAS530_DATA_CENTER		BIT(YAS530_DATA_BITS - 1)
79 #define YAS530_DATA_OVERFLOW		(BIT(YAS530_DATA_BITS) - 1)
80 
81 #define YAS532_DEVICE_ID		0x02 /* YAS532/YAS533 (MS-3R/F) */
82 #define YAS532_VERSION_AB		0 /* YAS532/533 AB (MS-3R/F AB) */
83 #define YAS532_VERSION_AC		1 /* YAS532/533 AC (MS-3R/F AC) */
84 #define YAS532_VERSION_AB_COEF		1800
85 #define YAS532_VERSION_AC_COEF_X	850
86 #define YAS532_VERSION_AC_COEF_Y1	750
87 #define YAS532_VERSION_AC_COEF_Y2	750
88 #define YAS532_DATA_BITS		13
89 #define YAS532_DATA_CENTER		BIT(YAS532_DATA_BITS - 1)
90 #define YAS532_DATA_OVERFLOW		(BIT(YAS532_DATA_BITS) - 1)
91 #define YAS532_20DEGREES		390 /* Looks like Kelvin */
92 
93 /* These variant IDs are known from code dumps */
94 #define YAS537_DEVICE_ID		0x07 /* YAS537 (MS-3T) */
95 #define YAS539_DEVICE_ID		0x08 /* YAS539 (MS-3S) */
96 
97 /* Turn off device regulators etc after 5 seconds of inactivity */
98 #define YAS5XX_AUTOSUSPEND_DELAY_MS	5000
99 
100 struct yas5xx_calibration {
101 	/* Linearization calibration x, y1, y2 */
102 	s32 r[3];
103 	u32 f[3];
104 	/* Temperature compensation calibration */
105 	s32 Cx, Cy1, Cy2;
106 	/* Misc calibration coefficients */
107 	s32 a2, a3, a4, a5, a6, a7, a8, a9, k;
108 	/* clock divider */
109 	u8 dck;
110 };
111 
112 /**
113  * struct yas5xx - state container for the YAS5xx driver
114  * @dev: parent device pointer
115  * @devid: device ID number
116  * @version: device version
117  * @name: device name
118  * @calibration: calibration settings from the OTP storage
119  * @hard_offsets: offsets for each axis measured with initcoil actuated
120  * @orientation: mounting matrix, flipped axis etc
121  * @map: regmap to access the YAX5xx registers over I2C
122  * @regs: the vdd and vddio power regulators
123  * @reset: optional GPIO line used for handling RESET
124  * @lock: locks the magnetometer for exclusive use during a measurement (which
125  * involves several register transactions so the regmap lock is not enough)
126  * so that measurements get serialized in a first-come-first serve manner
127  * @scan: naturally aligned measurements
128  */
129 struct yas5xx {
130 	struct device *dev;
131 	unsigned int devid;
132 	unsigned int version;
133 	char name[16];
134 	struct yas5xx_calibration calibration;
135 	u8 hard_offsets[3];
136 	struct iio_mount_matrix orientation;
137 	struct regmap *map;
138 	struct regulator_bulk_data regs[2];
139 	struct gpio_desc *reset;
140 	struct mutex lock;
141 	/*
142 	 * The scanout is 4 x 32 bits in CPU endianness.
143 	 * Ensure timestamp is naturally aligned
144 	 */
145 	struct {
146 		s32 channels[4];
147 		s64 ts __aligned(8);
148 	} scan;
149 };
150 
151 /* On YAS530 the x, y1 and y2 values are 12 bits */
152 static u16 yas530_extract_axis(u8 *data)
153 {
154 	u16 val;
155 
156 	/*
157 	 * These are the bits used in a 16bit word:
158 	 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
159 	 *    x  x  x  x  x  x  x  x  x  x  x  x
160 	 */
161 	val = get_unaligned_be16(&data[0]);
162 	val = FIELD_GET(GENMASK(14, 3), val);
163 	return val;
164 }
165 
166 /* On YAS532 the x, y1 and y2 values are 13 bits */
167 static u16 yas532_extract_axis(u8 *data)
168 {
169 	u16 val;
170 
171 	/*
172 	 * These are the bits used in a 16bit word:
173 	 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
174 	 *    x  x  x  x  x  x  x  x  x  x  x  x  x
175 	 */
176 	val = get_unaligned_be16(&data[0]);
177 	val = FIELD_GET(GENMASK(14, 2), val);
178 	return val;
179 }
180 
181 /**
182  * yas5xx_measure() - Make a measure from the hardware
183  * @yas5xx: The device state
184  * @t: the raw temperature measurement
185  * @x: the raw x axis measurement
186  * @y1: the y1 axis measurement
187  * @y2: the y2 axis measurement
188  * @return: 0 on success or error code
189  */
190 static int yas5xx_measure(struct yas5xx *yas5xx, u16 *t, u16 *x, u16 *y1, u16 *y2)
191 {
192 	unsigned int busy;
193 	u8 data[8];
194 	int ret;
195 	u16 val;
196 
197 	mutex_lock(&yas5xx->lock);
198 	ret = regmap_write(yas5xx->map, YAS5XX_MEASURE, YAS5XX_MEASURE_START);
199 	if (ret < 0)
200 		goto out_unlock;
201 
202 	/*
203 	 * Typical time to measure 1500 us, max 2000 us so wait min 500 us
204 	 * and at most 20000 us (one magnitude more than the datsheet max)
205 	 * before timeout.
206 	 */
207 	ret = regmap_read_poll_timeout(yas5xx->map, YAS5XX_MEASURE_DATA, busy,
208 				       !(busy & YAS5XX_MEASURE_DATA_BUSY),
209 				       500, 20000);
210 	if (ret) {
211 		dev_err(yas5xx->dev, "timeout waiting for measurement\n");
212 		goto out_unlock;
213 	}
214 
215 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_MEASURE_DATA,
216 			       data, sizeof(data));
217 	if (ret)
218 		goto out_unlock;
219 
220 	mutex_unlock(&yas5xx->lock);
221 
222 	switch (yas5xx->devid) {
223 	case YAS530_DEVICE_ID:
224 		/*
225 		 * The t value is 9 bits in big endian format
226 		 * These are the bits used in a 16bit word:
227 		 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
228 		 *    x  x  x  x  x  x  x  x  x
229 		 */
230 		val = get_unaligned_be16(&data[0]);
231 		val = FIELD_GET(GENMASK(14, 6), val);
232 		*t = val;
233 		*x = yas530_extract_axis(&data[2]);
234 		*y1 = yas530_extract_axis(&data[4]);
235 		*y2 = yas530_extract_axis(&data[6]);
236 		break;
237 	case YAS532_DEVICE_ID:
238 		/*
239 		 * The t value is 10 bits in big endian format
240 		 * These are the bits used in a 16bit word:
241 		 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
242 		 *    x  x  x  x  x  x  x  x  x  x
243 		 */
244 		val = get_unaligned_be16(&data[0]);
245 		val = FIELD_GET(GENMASK(14, 5), val);
246 		*t = val;
247 		*x = yas532_extract_axis(&data[2]);
248 		*y1 = yas532_extract_axis(&data[4]);
249 		*y2 = yas532_extract_axis(&data[6]);
250 		break;
251 	default:
252 		dev_err(yas5xx->dev, "unknown data format\n");
253 		ret = -EINVAL;
254 		break;
255 	}
256 
257 	return ret;
258 
259 out_unlock:
260 	mutex_unlock(&yas5xx->lock);
261 	return ret;
262 }
263 
264 static s32 yas5xx_linearize(struct yas5xx *yas5xx, u16 val, int axis)
265 {
266 	struct yas5xx_calibration *c = &yas5xx->calibration;
267 	static const s32 yas532ac_coef[] = {
268 		YAS532_VERSION_AC_COEF_X,
269 		YAS532_VERSION_AC_COEF_Y1,
270 		YAS532_VERSION_AC_COEF_Y2,
271 	};
272 	s32 coef;
273 
274 	/* Select coefficients */
275 	switch (yas5xx->devid) {
276 	case YAS530_DEVICE_ID:
277 		if (yas5xx->version == YAS530_VERSION_A)
278 			coef = YAS530_VERSION_A_COEF;
279 		else
280 			coef = YAS530_VERSION_B_COEF;
281 		break;
282 	case YAS532_DEVICE_ID:
283 		if (yas5xx->version == YAS532_VERSION_AB)
284 			coef = YAS532_VERSION_AB_COEF;
285 		else
286 			/* Elaborate coefficients */
287 			coef = yas532ac_coef[axis];
288 		break;
289 	default:
290 		dev_err(yas5xx->dev, "unknown device type\n");
291 		return val;
292 	}
293 	/*
294 	 * Linearization formula:
295 	 *
296 	 * x' = x - (3721 + 50 * f) + (xoffset - r) * c
297 	 *
298 	 * Where f and r are calibration values, c is a per-device
299 	 * and sometimes per-axis coefficient.
300 	 */
301 	return val - (3721 + 50 * c->f[axis]) +
302 		(yas5xx->hard_offsets[axis] - c->r[axis]) * coef;
303 }
304 
305 /**
306  * yas5xx_get_measure() - Measure a sample of all axis and process
307  * @yas5xx: The device state
308  * @to: Temperature out
309  * @xo: X axis out
310  * @yo: Y axis out
311  * @zo: Z axis out
312  * @return: 0 on success or error code
313  *
314  * Returned values are in nanotesla according to some code.
315  */
316 static int yas5xx_get_measure(struct yas5xx *yas5xx, s32 *to, s32 *xo, s32 *yo, s32 *zo)
317 {
318 	struct yas5xx_calibration *c = &yas5xx->calibration;
319 	u16 t, x, y1, y2;
320 	/* These are "signed x, signed y1 etc */
321 	s32 sx, sy1, sy2, sy, sz;
322 	int ret;
323 
324 	/* We first get raw data that needs to be translated to [x,y,z] */
325 	ret = yas5xx_measure(yas5xx, &t, &x, &y1, &y2);
326 	if (ret)
327 		return ret;
328 
329 	/* Do some linearization if available */
330 	sx = yas5xx_linearize(yas5xx, x, 0);
331 	sy1 = yas5xx_linearize(yas5xx, y1, 1);
332 	sy2 = yas5xx_linearize(yas5xx, y2, 2);
333 
334 	/*
335 	 * Temperature compensation for x, y1, y2 respectively:
336 	 *
337 	 *          Cx * t
338 	 * x' = x - ------
339 	 *           100
340 	 */
341 	sx = sx - (c->Cx * t) / 100;
342 	sy1 = sy1 - (c->Cy1 * t) / 100;
343 	sy2 = sy2 - (c->Cy2 * t) / 100;
344 
345 	/*
346 	 * Break y1 and y2 into y and z, y1 and y2 are apparently encoding
347 	 * y and z.
348 	 */
349 	sy = sy1 - sy2;
350 	sz = -sy1 - sy2;
351 
352 	/*
353 	 * FIXME: convert to Celsius? Just guessing this is given
354 	 * as 1/10:s of degrees so multiply by 100 to get millicentigrades.
355 	 */
356 	*to = t * 100;
357 	/*
358 	 * Calibrate [x,y,z] with some formulas like this:
359 	 *
360 	 *            100 * x + a_2 * y + a_3 * z
361 	 *  x' = k *  ---------------------------
362 	 *                        10
363 	 *
364 	 *           a_4 * x + a_5 * y + a_6 * z
365 	 *  y' = k * ---------------------------
366 	 *                        10
367 	 *
368 	 *           a_7 * x + a_8 * y + a_9 * z
369 	 *  z' = k * ---------------------------
370 	 *                        10
371 	 */
372 	*xo = c->k * ((100 * sx + c->a2 * sy + c->a3 * sz) / 10);
373 	*yo = c->k * ((c->a4 * sx + c->a5 * sy + c->a6 * sz) / 10);
374 	*zo = c->k * ((c->a7 * sx + c->a8 * sy + c->a9 * sz) / 10);
375 
376 	return 0;
377 }
378 
379 static int yas5xx_read_raw(struct iio_dev *indio_dev,
380 			   struct iio_chan_spec const *chan,
381 			   int *val, int *val2,
382 			   long mask)
383 {
384 	struct yas5xx *yas5xx = iio_priv(indio_dev);
385 	s32 t, x, y, z;
386 	int ret;
387 
388 	switch (mask) {
389 	case IIO_CHAN_INFO_RAW:
390 		pm_runtime_get_sync(yas5xx->dev);
391 		ret = yas5xx_get_measure(yas5xx, &t, &x, &y, &z);
392 		pm_runtime_mark_last_busy(yas5xx->dev);
393 		pm_runtime_put_autosuspend(yas5xx->dev);
394 		if (ret)
395 			return ret;
396 		switch (chan->address) {
397 		case 0:
398 			*val = t;
399 			break;
400 		case 1:
401 			*val = x;
402 			break;
403 		case 2:
404 			*val = y;
405 			break;
406 		case 3:
407 			*val = z;
408 			break;
409 		default:
410 			dev_err(yas5xx->dev, "unknown channel\n");
411 			return -EINVAL;
412 		}
413 		return IIO_VAL_INT;
414 	case IIO_CHAN_INFO_SCALE:
415 		if (chan->address == 0) {
416 			/* Temperature is unscaled */
417 			*val = 1;
418 			return IIO_VAL_INT;
419 		}
420 		/*
421 		 * The axis values are in nanotesla according to the vendor
422 		 * drivers, but is clearly in microtesla according to
423 		 * experiments. Since 1 uT = 0.01 Gauss, we need to divide
424 		 * by 100000000 (10^8) to get to Gauss from the raw value.
425 		 */
426 		*val = 1;
427 		*val2 = 100000000;
428 		return IIO_VAL_FRACTIONAL;
429 	default:
430 		/* Unknown request */
431 		return -EINVAL;
432 	}
433 }
434 
435 static void yas5xx_fill_buffer(struct iio_dev *indio_dev)
436 {
437 	struct yas5xx *yas5xx = iio_priv(indio_dev);
438 	s32 t, x, y, z;
439 	int ret;
440 
441 	pm_runtime_get_sync(yas5xx->dev);
442 	ret = yas5xx_get_measure(yas5xx, &t, &x, &y, &z);
443 	pm_runtime_mark_last_busy(yas5xx->dev);
444 	pm_runtime_put_autosuspend(yas5xx->dev);
445 	if (ret) {
446 		dev_err(yas5xx->dev, "error refilling buffer\n");
447 		return;
448 	}
449 	yas5xx->scan.channels[0] = t;
450 	yas5xx->scan.channels[1] = x;
451 	yas5xx->scan.channels[2] = y;
452 	yas5xx->scan.channels[3] = z;
453 	iio_push_to_buffers_with_timestamp(indio_dev, &yas5xx->scan,
454 					   iio_get_time_ns(indio_dev));
455 }
456 
457 static irqreturn_t yas5xx_handle_trigger(int irq, void *p)
458 {
459 	const struct iio_poll_func *pf = p;
460 	struct iio_dev *indio_dev = pf->indio_dev;
461 
462 	yas5xx_fill_buffer(indio_dev);
463 	iio_trigger_notify_done(indio_dev->trig);
464 
465 	return IRQ_HANDLED;
466 }
467 
468 
469 static const struct iio_mount_matrix *
470 yas5xx_get_mount_matrix(const struct iio_dev *indio_dev,
471 			const struct iio_chan_spec *chan)
472 {
473 	struct yas5xx *yas5xx = iio_priv(indio_dev);
474 
475 	return &yas5xx->orientation;
476 }
477 
478 static const struct iio_chan_spec_ext_info yas5xx_ext_info[] = {
479 	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, yas5xx_get_mount_matrix),
480 	{ }
481 };
482 
483 #define YAS5XX_AXIS_CHANNEL(axis, index)				\
484 	{								\
485 		.type = IIO_MAGN,					\
486 		.modified = 1,						\
487 		.channel2 = IIO_MOD_##axis,				\
488 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		\
489 			BIT(IIO_CHAN_INFO_SCALE),			\
490 		.ext_info = yas5xx_ext_info,				\
491 		.address = index,					\
492 		.scan_index = index,					\
493 		.scan_type = {						\
494 			.sign = 's',					\
495 			.realbits = 32,					\
496 			.storagebits = 32,				\
497 			.endianness = IIO_CPU,				\
498 		},							\
499 	}
500 
501 static const struct iio_chan_spec yas5xx_channels[] = {
502 	{
503 		.type = IIO_TEMP,
504 		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
505 		.address = 0,
506 		.scan_index = 0,
507 		.scan_type = {
508 			.sign = 'u',
509 			.realbits = 32,
510 			.storagebits = 32,
511 			.endianness = IIO_CPU,
512 		},
513 	},
514 	YAS5XX_AXIS_CHANNEL(X, 1),
515 	YAS5XX_AXIS_CHANNEL(Y, 2),
516 	YAS5XX_AXIS_CHANNEL(Z, 3),
517 	IIO_CHAN_SOFT_TIMESTAMP(4),
518 };
519 
520 static const unsigned long yas5xx_scan_masks[] = { GENMASK(3, 0), 0 };
521 
522 static const struct iio_info yas5xx_info = {
523 	.read_raw = &yas5xx_read_raw,
524 };
525 
526 static bool yas5xx_volatile_reg(struct device *dev, unsigned int reg)
527 {
528 	return reg == YAS5XX_ACTUATE_INIT_COIL ||
529 		reg == YAS5XX_MEASURE ||
530 		(reg >= YAS5XX_MEASURE_DATA && reg <= YAS5XX_MEASURE_DATA + 8);
531 }
532 
533 /* TODO: enable regmap cache, using mark dirty and sync at runtime resume */
534 static const struct regmap_config yas5xx_regmap_config = {
535 	.reg_bits = 8,
536 	.val_bits = 8,
537 	.max_register = 0xff,
538 	.volatile_reg = yas5xx_volatile_reg,
539 };
540 
541 /**
542  * yas53x_extract_calibration() - extracts the a2-a9 and k calibration
543  * @data: the bitfield to use
544  * @c: the calibration to populate
545  */
546 static void yas53x_extract_calibration(u8 *data, struct yas5xx_calibration *c)
547 {
548 	u64 val = get_unaligned_be64(data);
549 
550 	/*
551 	 * Bitfield layout for the axis calibration data, for factor
552 	 * a2 = 2 etc, k = k, c = clock divider
553 	 *
554 	 * n   7 6 5 4 3 2 1 0
555 	 * 0 [ 2 2 2 2 2 2 3 3 ] bits 63 .. 56
556 	 * 1 [ 3 3 4 4 4 4 4 4 ] bits 55 .. 48
557 	 * 2 [ 5 5 5 5 5 5 6 6 ] bits 47 .. 40
558 	 * 3 [ 6 6 6 6 7 7 7 7 ] bits 39 .. 32
559 	 * 4 [ 7 7 7 8 8 8 8 8 ] bits 31 .. 24
560 	 * 5 [ 8 9 9 9 9 9 9 9 ] bits 23 .. 16
561 	 * 6 [ 9 k k k k k c c ] bits 15 .. 8
562 	 * 7 [ c x x x x x x x ] bits  7 .. 0
563 	 */
564 	c->a2 = FIELD_GET(GENMASK_ULL(63, 58), val) - 32;
565 	c->a3 = FIELD_GET(GENMASK_ULL(57, 54), val) - 8;
566 	c->a4 = FIELD_GET(GENMASK_ULL(53, 48), val) - 32;
567 	c->a5 = FIELD_GET(GENMASK_ULL(47, 42), val) + 38;
568 	c->a6 = FIELD_GET(GENMASK_ULL(41, 36), val) - 32;
569 	c->a7 = FIELD_GET(GENMASK_ULL(35, 29), val) - 64;
570 	c->a8 = FIELD_GET(GENMASK_ULL(28, 23), val) - 32;
571 	c->a9 = FIELD_GET(GENMASK_ULL(22, 15), val);
572 	c->k = FIELD_GET(GENMASK_ULL(14, 10), val) + 10;
573 	c->dck = FIELD_GET(GENMASK_ULL(9, 7), val);
574 }
575 
576 static int yas530_get_calibration_data(struct yas5xx *yas5xx)
577 {
578 	struct yas5xx_calibration *c = &yas5xx->calibration;
579 	u8 data[16];
580 	u32 val;
581 	int ret;
582 
583 	/* Dummy read, first read is ALWAYS wrong */
584 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_CAL, data, sizeof(data));
585 	if (ret)
586 		return ret;
587 
588 	/* Actual calibration readout */
589 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_CAL, data, sizeof(data));
590 	if (ret)
591 		return ret;
592 	dev_dbg(yas5xx->dev, "calibration data: %*ph\n", 14, data);
593 
594 	add_device_randomness(data, sizeof(data));
595 	yas5xx->version = data[15] & GENMASK(1, 0);
596 
597 	/* Extract the calibration from the bitfield */
598 	c->Cx = data[0] * 6 - 768;
599 	c->Cy1 = data[1] * 6 - 768;
600 	c->Cy2 = data[2] * 6 - 768;
601 	yas53x_extract_calibration(&data[3], c);
602 
603 	/*
604 	 * Extract linearization:
605 	 * Linearization layout in the 32 bits at byte 11:
606 	 * The r factors are 6 bit values where bit 5 is the sign
607 	 *
608 	 * n    7  6  5  4  3  2  1  0
609 	 * 0 [ xx xx xx r0 r0 r0 r0 r0 ] bits 31 .. 24
610 	 * 1 [ r0 f0 f0 r1 r1 r1 r1 r1 ] bits 23 .. 16
611 	 * 2 [ r1 f1 f1 r2 r2 r2 r2 r2 ] bits 15 .. 8
612 	 * 3 [ r2 f2 f2 xx xx xx xx xx ] bits  7 .. 0
613 	 */
614 	val = get_unaligned_be32(&data[11]);
615 	c->f[0] = FIELD_GET(GENMASK(22, 21), val);
616 	c->f[1] = FIELD_GET(GENMASK(14, 13), val);
617 	c->f[2] = FIELD_GET(GENMASK(6, 5), val);
618 	c->r[0] = sign_extend32(FIELD_GET(GENMASK(28, 23), val), 5);
619 	c->r[1] = sign_extend32(FIELD_GET(GENMASK(20, 15), val), 5);
620 	c->r[2] = sign_extend32(FIELD_GET(GENMASK(12, 7), val), 5);
621 	return 0;
622 }
623 
624 static int yas532_get_calibration_data(struct yas5xx *yas5xx)
625 {
626 	struct yas5xx_calibration *c = &yas5xx->calibration;
627 	u8 data[14];
628 	u32 val;
629 	int ret;
630 
631 	/* Dummy read, first read is ALWAYS wrong */
632 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_CAL, data, sizeof(data));
633 	if (ret)
634 		return ret;
635 	/* Actual calibration readout */
636 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_CAL, data, sizeof(data));
637 	if (ret)
638 		return ret;
639 	dev_dbg(yas5xx->dev, "calibration data: %*ph\n", 14, data);
640 
641 	/* Sanity check, is this all zeroes? */
642 	if (memchr_inv(data, 0x00, 13) == NULL) {
643 		if (!(data[13] & BIT(7)))
644 			dev_warn(yas5xx->dev, "calibration is blank!\n");
645 	}
646 
647 	add_device_randomness(data, sizeof(data));
648 	/* Only one bit of version info reserved here as far as we know */
649 	yas5xx->version = data[13] & BIT(0);
650 
651 	/* Extract calibration from the bitfield */
652 	c->Cx = data[0] * 10 - 1280;
653 	c->Cy1 = data[1] * 10 - 1280;
654 	c->Cy2 = data[2] * 10 - 1280;
655 	yas53x_extract_calibration(&data[3], c);
656 	/*
657 	 * Extract linearization:
658 	 * Linearization layout in the 32 bits at byte 10:
659 	 * The r factors are 6 bit values where bit 5 is the sign
660 	 *
661 	 * n    7  6  5  4  3  2  1  0
662 	 * 0 [ xx r0 r0 r0 r0 r0 r0 f0 ] bits 31 .. 24
663 	 * 1 [ f0 r1 r1 r1 r1 r1 r1 f1 ] bits 23 .. 16
664 	 * 2 [ f1 r2 r2 r2 r2 r2 r2 f2 ] bits 15 .. 8
665 	 * 3 [ f2 xx xx xx xx xx xx xx ] bits  7 .. 0
666 	 */
667 	val = get_unaligned_be32(&data[10]);
668 	c->f[0] = FIELD_GET(GENMASK(24, 23), val);
669 	c->f[1] = FIELD_GET(GENMASK(16, 15), val);
670 	c->f[2] = FIELD_GET(GENMASK(8, 7), val);
671 	c->r[0] = sign_extend32(FIELD_GET(GENMASK(30, 25), val), 5);
672 	c->r[1] = sign_extend32(FIELD_GET(GENMASK(22, 17), val), 5);
673 	c->r[2] = sign_extend32(FIELD_GET(GENMASK(14, 7), val), 5);
674 
675 	return 0;
676 }
677 
678 static void yas5xx_dump_calibration(struct yas5xx *yas5xx)
679 {
680 	struct yas5xx_calibration *c = &yas5xx->calibration;
681 
682 	dev_dbg(yas5xx->dev, "f[] = [%d, %d, %d]\n",
683 		c->f[0], c->f[1], c->f[2]);
684 	dev_dbg(yas5xx->dev, "r[] = [%d, %d, %d]\n",
685 		c->r[0], c->r[1], c->r[2]);
686 	dev_dbg(yas5xx->dev, "Cx = %d\n", c->Cx);
687 	dev_dbg(yas5xx->dev, "Cy1 = %d\n", c->Cy1);
688 	dev_dbg(yas5xx->dev, "Cy2 = %d\n", c->Cy2);
689 	dev_dbg(yas5xx->dev, "a2 = %d\n", c->a2);
690 	dev_dbg(yas5xx->dev, "a3 = %d\n", c->a3);
691 	dev_dbg(yas5xx->dev, "a4 = %d\n", c->a4);
692 	dev_dbg(yas5xx->dev, "a5 = %d\n", c->a5);
693 	dev_dbg(yas5xx->dev, "a6 = %d\n", c->a6);
694 	dev_dbg(yas5xx->dev, "a7 = %d\n", c->a7);
695 	dev_dbg(yas5xx->dev, "a8 = %d\n", c->a8);
696 	dev_dbg(yas5xx->dev, "a9 = %d\n", c->a9);
697 	dev_dbg(yas5xx->dev, "k = %d\n", c->k);
698 	dev_dbg(yas5xx->dev, "dck = %d\n", c->dck);
699 }
700 
701 static int yas5xx_set_offsets(struct yas5xx *yas5xx, s8 ox, s8 oy1, s8 oy2)
702 {
703 	int ret;
704 
705 	ret = regmap_write(yas5xx->map, YAS5XX_OFFSET_X, ox);
706 	if (ret)
707 		return ret;
708 	ret = regmap_write(yas5xx->map, YAS5XX_OFFSET_Y1, oy1);
709 	if (ret)
710 		return ret;
711 	return regmap_write(yas5xx->map, YAS5XX_OFFSET_Y2, oy2);
712 }
713 
714 static s8 yas5xx_adjust_offset(s8 old, int bit, u16 center, u16 measure)
715 {
716 	if (measure > center)
717 		return old + BIT(bit);
718 	if (measure < center)
719 		return old - BIT(bit);
720 	return old;
721 }
722 
723 static int yas5xx_meaure_offsets(struct yas5xx *yas5xx)
724 {
725 	int ret;
726 	u16 center;
727 	u16 t, x, y1, y2;
728 	s8 ox, oy1, oy2;
729 	int i;
730 
731 	/* Actuate the init coil and measure offsets */
732 	ret = regmap_write(yas5xx->map, YAS5XX_ACTUATE_INIT_COIL, 0);
733 	if (ret)
734 		return ret;
735 
736 	/* When the initcoil is active this should be around the center */
737 	switch (yas5xx->devid) {
738 	case YAS530_DEVICE_ID:
739 		center = YAS530_DATA_CENTER;
740 		break;
741 	case YAS532_DEVICE_ID:
742 		center = YAS532_DATA_CENTER;
743 		break;
744 	default:
745 		dev_err(yas5xx->dev, "unknown device type\n");
746 		return -EINVAL;
747 	}
748 
749 	/*
750 	 * We set offsets in the interval +-31 by iterating
751 	 * +-16, +-8, +-4, +-2, +-1 adjusting the offsets each
752 	 * time, then writing the final offsets into the
753 	 * registers.
754 	 *
755 	 * NOTE: these offsets are NOT in the same unit or magnitude
756 	 * as the values for [x, y1, y2]. The value is +/-31
757 	 * but the effect on the raw values is much larger.
758 	 * The effect of the offset is to bring the measure
759 	 * rougly to the center.
760 	 */
761 	ox = 0;
762 	oy1 = 0;
763 	oy2 = 0;
764 
765 	for (i = 4; i >= 0; i--) {
766 		ret = yas5xx_set_offsets(yas5xx, ox, oy1, oy2);
767 		if (ret)
768 			return ret;
769 
770 		ret = yas5xx_measure(yas5xx, &t, &x, &y1, &y2);
771 		if (ret)
772 			return ret;
773 		dev_dbg(yas5xx->dev, "measurement %d: x=%d, y1=%d, y2=%d\n",
774 			5-i, x, y1, y2);
775 
776 		ox = yas5xx_adjust_offset(ox, i, center, x);
777 		oy1 = yas5xx_adjust_offset(oy1, i, center, y1);
778 		oy2 = yas5xx_adjust_offset(oy2, i, center, y2);
779 	}
780 
781 	/* Needed for calibration algorithm */
782 	yas5xx->hard_offsets[0] = ox;
783 	yas5xx->hard_offsets[1] = oy1;
784 	yas5xx->hard_offsets[2] = oy2;
785 	ret = yas5xx_set_offsets(yas5xx, ox, oy1, oy2);
786 	if (ret)
787 		return ret;
788 
789 	dev_info(yas5xx->dev, "discovered hard offsets: x=%d, y1=%d, y2=%d\n",
790 		 ox, oy1, oy2);
791 	return 0;
792 }
793 
794 static int yas5xx_power_on(struct yas5xx *yas5xx)
795 {
796 	unsigned int val;
797 	int ret;
798 
799 	/* Zero the test registers */
800 	ret = regmap_write(yas5xx->map, YAS5XX_TEST1, 0);
801 	if (ret)
802 		return ret;
803 	ret = regmap_write(yas5xx->map, YAS5XX_TEST2, 0);
804 	if (ret)
805 		return ret;
806 
807 	/* Set up for no interrupts, calibrated clock divider */
808 	val = FIELD_PREP(YAS5XX_CONFIG_CCK_MASK, yas5xx->calibration.dck);
809 	ret = regmap_write(yas5xx->map, YAS5XX_CONFIG, val);
810 	if (ret)
811 		return ret;
812 
813 	/* Measure interval 0 (back-to-back?)  */
814 	return regmap_write(yas5xx->map, YAS5XX_MEASURE_INTERVAL, 0);
815 }
816 
817 static int yas5xx_probe(struct i2c_client *i2c,
818 			const struct i2c_device_id *id)
819 {
820 	struct iio_dev *indio_dev;
821 	struct device *dev = &i2c->dev;
822 	struct yas5xx *yas5xx;
823 	int ret;
824 
825 	indio_dev = devm_iio_device_alloc(dev, sizeof(*yas5xx));
826 	if (!indio_dev)
827 		return -ENOMEM;
828 
829 	yas5xx = iio_priv(indio_dev);
830 	i2c_set_clientdata(i2c, indio_dev);
831 	yas5xx->dev = dev;
832 	mutex_init(&yas5xx->lock);
833 
834 	ret = iio_read_mount_matrix(dev, &yas5xx->orientation);
835 	if (ret)
836 		return ret;
837 
838 	yas5xx->regs[0].supply = "vdd";
839 	yas5xx->regs[1].supply = "iovdd";
840 	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(yas5xx->regs),
841 				      yas5xx->regs);
842 	if (ret)
843 		return dev_err_probe(dev, ret, "cannot get regulators\n");
844 
845 	ret = regulator_bulk_enable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
846 	if (ret) {
847 		dev_err(dev, "cannot enable regulators\n");
848 		return ret;
849 	}
850 
851 	/* See comment in runtime resume callback */
852 	usleep_range(31000, 40000);
853 
854 	/* This will take the device out of reset if need be */
855 	yas5xx->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
856 	if (IS_ERR(yas5xx->reset)) {
857 		ret = dev_err_probe(dev, PTR_ERR(yas5xx->reset),
858 				    "failed to get reset line\n");
859 		goto reg_off;
860 	}
861 
862 	yas5xx->map = devm_regmap_init_i2c(i2c, &yas5xx_regmap_config);
863 	if (IS_ERR(yas5xx->map)) {
864 		dev_err(dev, "failed to allocate register map\n");
865 		ret = PTR_ERR(yas5xx->map);
866 		goto assert_reset;
867 	}
868 
869 	ret = regmap_read(yas5xx->map, YAS5XX_DEVICE_ID, &yas5xx->devid);
870 	if (ret)
871 		goto assert_reset;
872 
873 	switch (yas5xx->devid) {
874 	case YAS530_DEVICE_ID:
875 		ret = yas530_get_calibration_data(yas5xx);
876 		if (ret)
877 			goto assert_reset;
878 		dev_info(dev, "detected YAS530 MS-3E %s",
879 			 yas5xx->version ? "B" : "A");
880 		strncpy(yas5xx->name, "yas530", sizeof(yas5xx->name));
881 		break;
882 	case YAS532_DEVICE_ID:
883 		ret = yas532_get_calibration_data(yas5xx);
884 		if (ret)
885 			goto assert_reset;
886 		dev_info(dev, "detected YAS532/YAS533 MS-3R/F %s",
887 			 yas5xx->version ? "AC" : "AB");
888 		strncpy(yas5xx->name, "yas532", sizeof(yas5xx->name));
889 		break;
890 	default:
891 		ret = -ENODEV;
892 		dev_err(dev, "unhandled device ID %02x\n", yas5xx->devid);
893 		goto assert_reset;
894 	}
895 
896 	yas5xx_dump_calibration(yas5xx);
897 	ret = yas5xx_power_on(yas5xx);
898 	if (ret)
899 		goto assert_reset;
900 	ret = yas5xx_meaure_offsets(yas5xx);
901 	if (ret)
902 		goto assert_reset;
903 
904 	indio_dev->info = &yas5xx_info;
905 	indio_dev->available_scan_masks = yas5xx_scan_masks;
906 	indio_dev->modes = INDIO_DIRECT_MODE;
907 	indio_dev->name = yas5xx->name;
908 	indio_dev->channels = yas5xx_channels;
909 	indio_dev->num_channels = ARRAY_SIZE(yas5xx_channels);
910 
911 	ret = iio_triggered_buffer_setup(indio_dev, NULL,
912 					 yas5xx_handle_trigger,
913 					 NULL);
914 	if (ret) {
915 		dev_err(dev, "triggered buffer setup failed\n");
916 		goto assert_reset;
917 	}
918 
919 	ret = iio_device_register(indio_dev);
920 	if (ret) {
921 		dev_err(dev, "device register failed\n");
922 		goto cleanup_buffer;
923 	}
924 
925 	/* Take runtime PM online */
926 	pm_runtime_get_noresume(dev);
927 	pm_runtime_set_active(dev);
928 	pm_runtime_enable(dev);
929 
930 	pm_runtime_set_autosuspend_delay(dev, YAS5XX_AUTOSUSPEND_DELAY_MS);
931 	pm_runtime_use_autosuspend(dev);
932 	pm_runtime_put(dev);
933 
934 	return 0;
935 
936 cleanup_buffer:
937 	iio_triggered_buffer_cleanup(indio_dev);
938 assert_reset:
939 	gpiod_set_value_cansleep(yas5xx->reset, 1);
940 reg_off:
941 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
942 
943 	return ret;
944 }
945 
946 static int yas5xx_remove(struct i2c_client *i2c)
947 {
948 	struct iio_dev *indio_dev = i2c_get_clientdata(i2c);
949 	struct yas5xx *yas5xx = iio_priv(indio_dev);
950 	struct device *dev = &i2c->dev;
951 
952 	iio_device_unregister(indio_dev);
953 	iio_triggered_buffer_cleanup(indio_dev);
954 	/*
955 	 * Now we can't get any more reads from the device, which would
956 	 * also call pm_runtime* functions and race with our disable
957 	 * code. Disable PM runtime in orderly fashion and power down.
958 	 */
959 	pm_runtime_get_sync(dev);
960 	pm_runtime_put_noidle(dev);
961 	pm_runtime_disable(dev);
962 	gpiod_set_value_cansleep(yas5xx->reset, 1);
963 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
964 
965 	return 0;
966 }
967 
968 static int __maybe_unused yas5xx_runtime_suspend(struct device *dev)
969 {
970 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
971 	struct yas5xx *yas5xx = iio_priv(indio_dev);
972 
973 	gpiod_set_value_cansleep(yas5xx->reset, 1);
974 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
975 
976 	return 0;
977 }
978 
979 static int __maybe_unused yas5xx_runtime_resume(struct device *dev)
980 {
981 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
982 	struct yas5xx *yas5xx = iio_priv(indio_dev);
983 	int ret;
984 
985 	ret = regulator_bulk_enable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
986 	if (ret) {
987 		dev_err(dev, "cannot enable regulators\n");
988 		return ret;
989 	}
990 
991 	/*
992 	 * The YAS530 datasheet says TVSKW is up to 30 ms, after that 1 ms
993 	 * for all voltages to settle. The YAS532 is 10ms then 4ms for the
994 	 * I2C to come online. Let's keep it safe and put this at 31ms.
995 	 */
996 	usleep_range(31000, 40000);
997 	gpiod_set_value_cansleep(yas5xx->reset, 0);
998 
999 	ret = yas5xx_power_on(yas5xx);
1000 	if (ret) {
1001 		dev_err(dev, "cannot power on\n");
1002 		goto out_reset;
1003 	}
1004 
1005 	return 0;
1006 
1007 out_reset:
1008 	gpiod_set_value_cansleep(yas5xx->reset, 1);
1009 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1010 
1011 	return ret;
1012 }
1013 
1014 static const struct dev_pm_ops yas5xx_dev_pm_ops = {
1015 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1016 				pm_runtime_force_resume)
1017 	SET_RUNTIME_PM_OPS(yas5xx_runtime_suspend,
1018 			   yas5xx_runtime_resume, NULL)
1019 };
1020 
1021 static const struct i2c_device_id yas5xx_id[] = {
1022 	{"yas530", },
1023 	{"yas532", },
1024 	{"yas533", },
1025 	{}
1026 };
1027 MODULE_DEVICE_TABLE(i2c, yas5xx_id);
1028 
1029 static const struct of_device_id yas5xx_of_match[] = {
1030 	{ .compatible = "yamaha,yas530", },
1031 	{ .compatible = "yamaha,yas532", },
1032 	{ .compatible = "yamaha,yas533", },
1033 	{}
1034 };
1035 MODULE_DEVICE_TABLE(of, yas5xx_of_match);
1036 
1037 static struct i2c_driver yas5xx_driver = {
1038 	.driver	 = {
1039 		.name	= "yas5xx",
1040 		.of_match_table = yas5xx_of_match,
1041 		.pm = &yas5xx_dev_pm_ops,
1042 	},
1043 	.probe	  = yas5xx_probe,
1044 	.remove	  = yas5xx_remove,
1045 	.id_table = yas5xx_id,
1046 };
1047 module_i2c_driver(yas5xx_driver);
1048 
1049 MODULE_DESCRIPTION("Yamaha YAS53x 3-axis magnetometer driver");
1050 MODULE_AUTHOR("Linus Walleij");
1051 MODULE_LICENSE("GPL v2");
1052