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, Galaxy S7)
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  * Code functions for YAS537 based on Yamaha Android kernel driver.
21  * Copyright (c) 2014 Yamaha Corporation
22  *
23  * Author: Linus Walleij <linus.walleij@linaro.org>
24  */
25 #include <linux/bitfield.h>
26 #include <linux/bitops.h>
27 #include <linux/delay.h>
28 #include <linux/err.h>
29 #include <linux/gpio/consumer.h>
30 #include <linux/i2c.h>
31 #include <linux/module.h>
32 #include <linux/mod_devicetable.h>
33 #include <linux/mutex.h>
34 #include <linux/pm_runtime.h>
35 #include <linux/property.h>
36 #include <linux/regmap.h>
37 #include <linux/regulator/consumer.h>
38 #include <linux/random.h>
39 #include <linux/units.h>
40 
41 #include <linux/iio/buffer.h>
42 #include <linux/iio/iio.h>
43 #include <linux/iio/trigger_consumer.h>
44 #include <linux/iio/triggered_buffer.h>
45 
46 #include <asm/unaligned.h>
47 
48 /* Commonly used registers */
49 #define YAS5XX_DEVICE_ID		0x80
50 #define YAS5XX_MEASURE_DATA		0xB0
51 
52 /* These registers are used by YAS530, YAS532 and YAS533 */
53 #define YAS530_ACTUATE_INIT_COIL	0x81
54 #define YAS530_MEASURE			0x82
55 #define YAS530_CONFIG			0x83
56 #define YAS530_MEASURE_INTERVAL		0x84
57 #define YAS530_OFFSET_X			0x85 /* [-31 .. 31] */
58 #define YAS530_OFFSET_Y1		0x86 /* [-31 .. 31] */
59 #define YAS530_OFFSET_Y2		0x87 /* [-31 .. 31] */
60 #define YAS530_TEST1			0x88
61 #define YAS530_TEST2			0x89
62 #define YAS530_CAL			0x90
63 
64 /* Registers used by YAS537 */
65 #define YAS537_MEASURE			0x81 /* Originally YAS537_REG_CMDR */
66 #define YAS537_CONFIG			0x82 /* Originally YAS537_REG_CONFR */
67 #define YAS537_MEASURE_INTERVAL		0x83 /* Originally YAS537_REG_INTRVLR */
68 #define YAS537_OFFSET_X			0x84 /* Originally YAS537_REG_OXR */
69 #define YAS537_OFFSET_Y1		0x85 /* Originally YAS537_REG_OY1R */
70 #define YAS537_OFFSET_Y2		0x86 /* Originally YAS537_REG_OY2R */
71 #define YAS537_AVR			0x87
72 #define YAS537_HCK			0x88
73 #define YAS537_LCK			0x89
74 #define YAS537_SRST			0x90
75 #define YAS537_ADCCAL			0x91
76 #define YAS537_MTC			0x93
77 #define YAS537_OC			0x9E
78 #define YAS537_TRM			0x9F
79 #define YAS537_CAL			0xC0
80 
81 /* Bits in the YAS5xx config register */
82 #define YAS5XX_CONFIG_INTON		BIT(0) /* Interrupt on? */
83 #define YAS5XX_CONFIG_INTHACT		BIT(1) /* Interrupt active high? */
84 #define YAS5XX_CONFIG_CCK_MASK		GENMASK(4, 2)
85 #define YAS5XX_CONFIG_CCK_SHIFT		2
86 
87 /* Bits in the measure command register */
88 #define YAS5XX_MEASURE_START		BIT(0)
89 #define YAS5XX_MEASURE_LDTC		BIT(1)
90 #define YAS5XX_MEASURE_FORS		BIT(2)
91 #define YAS5XX_MEASURE_DLYMES		BIT(4)
92 #define YAS5XX_MEASURE_CONT		BIT(5)
93 
94 /* Bits in the measure data register */
95 #define YAS5XX_MEASURE_DATA_BUSY	BIT(7)
96 
97 #define YAS530_DEVICE_ID		0x01 /* YAS530 (MS-3E) */
98 #define YAS530_VERSION_A		0 /* YAS530 (MS-3E A) */
99 #define YAS530_VERSION_B		1 /* YAS530B (MS-3E B) */
100 #define YAS530_VERSION_A_COEF		380
101 #define YAS530_VERSION_B_COEF		550
102 #define YAS530_DATA_BITS		12
103 #define YAS530_DATA_CENTER		BIT(YAS530_DATA_BITS - 1)
104 #define YAS530_DATA_OVERFLOW		(BIT(YAS530_DATA_BITS) - 1)
105 
106 #define YAS532_DEVICE_ID		0x02 /* YAS532/YAS533 (MS-3R/F) */
107 #define YAS532_VERSION_AB		0 /* YAS532/533 AB (MS-3R/F AB) */
108 #define YAS532_VERSION_AC		1 /* YAS532/533 AC (MS-3R/F AC) */
109 #define YAS532_VERSION_AB_COEF		1800
110 #define YAS532_VERSION_AC_COEF_X	850
111 #define YAS532_VERSION_AC_COEF_Y1	750
112 #define YAS532_VERSION_AC_COEF_Y2	750
113 #define YAS532_DATA_BITS		13
114 #define YAS532_DATA_CENTER		BIT(YAS532_DATA_BITS - 1)
115 #define YAS532_DATA_OVERFLOW		(BIT(YAS532_DATA_BITS) - 1)
116 
117 #define YAS537_DEVICE_ID		0x07 /* YAS537 (MS-3T) */
118 #define YAS537_VERSION_0		0 /* Version naming unknown */
119 #define YAS537_VERSION_1		1 /* Version naming unknown */
120 #define YAS537_MAG_AVERAGE_32_MASK	GENMASK(6, 4)
121 #define YAS537_MEASURE_TIME_WORST_US	1500
122 #define YAS537_DEFAULT_SENSOR_DELAY_MS	50
123 #define YAS537_MAG_RCOIL_TIME_US	65
124 #define YAS537_MTC3_MASK_PREP		GENMASK(7, 0)
125 #define YAS537_MTC3_MASK_GET		GENMASK(7, 5)
126 #define YAS537_MTC3_ADD_BIT		BIT(4)
127 #define YAS537_HCK_MASK_PREP		GENMASK(4, 0)
128 #define YAS537_HCK_MASK_GET		GENMASK(7, 4)
129 #define YAS537_LCK_MASK_PREP		GENMASK(4, 0)
130 #define YAS537_LCK_MASK_GET		GENMASK(3, 0)
131 #define YAS537_OC_MASK_GET		GENMASK(5, 0)
132 
133 /* Turn off device regulators etc after 5 seconds of inactivity */
134 #define YAS5XX_AUTOSUSPEND_DELAY_MS	5000
135 
136 enum chip_ids {
137 	yas530,
138 	yas532,
139 	yas533,
140 	yas537,
141 };
142 
143 static const int yas530_volatile_reg[] = {
144 	YAS530_ACTUATE_INIT_COIL,
145 	YAS530_MEASURE,
146 };
147 
148 static const int yas537_volatile_reg[] = {
149 	YAS537_MEASURE,
150 };
151 
152 struct yas5xx_calibration {
153 	/* Linearization calibration x, y1, y2 */
154 	s32 r[3];
155 	u32 f[3];
156 	/* Temperature compensation calibration */
157 	s16 Cx, Cy1, Cy2;
158 	/* Misc calibration coefficients */
159 	s8  a2, a3, a4, a6, a7, a8;
160 	s16 a5, a9;
161 	u8  k;
162 	/* clock divider */
163 	u8 dck;
164 };
165 
166 struct yas5xx;
167 
168 /**
169  * struct yas5xx_chip_info - device-specific data and function pointers
170  * @devid: device ID number
171  * @product_name: product name of the YAS variant
172  * @version_names: version letters or namings
173  * @volatile_reg: device-specific volatile registers
174  * @volatile_reg_qty: quantity of device-specific volatile registers
175  * @scaling_val2: scaling value for IIO_CHAN_INFO_SCALE
176  * @t_ref: number of counts at reference temperature 20 °C
177  * @min_temp_x10: starting point of temperature counting in 1/10:s degrees Celsius
178  * @get_measure: function pointer to get a measurement
179  * @get_calibration_data: function pointer to get calibration data
180  * @dump_calibration: function pointer to dump calibration for debugging
181  * @measure_offsets: function pointer to measure the offsets
182  * @power_on: function pointer to power-on procedure
183  *
184  * The "t_ref" value for YAS532/533 is known from the Android driver.
185  * For YAS530 and YAS537 it was approximately measured.
186  *
187  * The temperatures "min_temp_x10" are derived from the temperature resolutions
188  * given in the data sheets.
189  */
190 struct yas5xx_chip_info {
191 	unsigned int devid;
192 	const char *product_name;
193 	const char *version_names[2];
194 	const int *volatile_reg;
195 	int volatile_reg_qty;
196 	u32 scaling_val2;
197 	u16 t_ref;
198 	s16 min_temp_x10;
199 	int (*get_measure)(struct yas5xx *yas5xx, s32 *to, s32 *xo, s32 *yo, s32 *zo);
200 	int (*get_calibration_data)(struct yas5xx *yas5xx);
201 	void (*dump_calibration)(struct yas5xx *yas5xx);
202 	int (*measure_offsets)(struct yas5xx *yas5xx);
203 	int (*power_on)(struct yas5xx *yas5xx);
204 };
205 
206 /**
207  * struct yas5xx - state container for the YAS5xx driver
208  * @dev: parent device pointer
209  * @chip_info: device-specific data and function pointers
210  * @version: device version
211  * @calibration: calibration settings from the OTP storage
212  * @hard_offsets: offsets for each axis measured with initcoil actuated
213  * @orientation: mounting matrix, flipped axis etc
214  * @map: regmap to access the YAX5xx registers over I2C
215  * @regs: the vdd and vddio power regulators
216  * @reset: optional GPIO line used for handling RESET
217  * @lock: locks the magnetometer for exclusive use during a measurement (which
218  * involves several register transactions so the regmap lock is not enough)
219  * so that measurements get serialized in a first-come-first serve manner
220  * @scan: naturally aligned measurements
221  */
222 struct yas5xx {
223 	struct device *dev;
224 	const struct yas5xx_chip_info *chip_info;
225 	unsigned int version;
226 	struct yas5xx_calibration calibration;
227 	s8 hard_offsets[3];
228 	struct iio_mount_matrix orientation;
229 	struct regmap *map;
230 	struct regulator_bulk_data regs[2];
231 	struct gpio_desc *reset;
232 	struct mutex lock;
233 	/*
234 	 * The scanout is 4 x 32 bits in CPU endianness.
235 	 * Ensure timestamp is naturally aligned
236 	 */
237 	struct {
238 		s32 channels[4];
239 		s64 ts __aligned(8);
240 	} scan;
241 };
242 
243 /* On YAS530 the x, y1 and y2 values are 12 bits */
244 static u16 yas530_extract_axis(u8 *data)
245 {
246 	u16 val;
247 
248 	/*
249 	 * These are the bits used in a 16bit word:
250 	 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
251 	 *    x  x  x  x  x  x  x  x  x  x  x  x
252 	 */
253 	val = get_unaligned_be16(&data[0]);
254 	val = FIELD_GET(GENMASK(14, 3), val);
255 	return val;
256 }
257 
258 /* On YAS532 the x, y1 and y2 values are 13 bits */
259 static u16 yas532_extract_axis(u8 *data)
260 {
261 	u16 val;
262 
263 	/*
264 	 * These are the bits used in a 16bit word:
265 	 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
266 	 *    x  x  x  x  x  x  x  x  x  x  x  x  x
267 	 */
268 	val = get_unaligned_be16(&data[0]);
269 	val = FIELD_GET(GENMASK(14, 2), val);
270 	return val;
271 }
272 
273 /**
274  * yas530_measure() - Make a measure from the hardware
275  * @yas5xx: The device state
276  * @t: the raw temperature measurement
277  * @x: the raw x axis measurement
278  * @y1: the y1 axis measurement
279  * @y2: the y2 axis measurement
280  * @return: 0 on success or error code
281  *
282  * Used by YAS530, YAS532 and YAS533.
283  */
284 static int yas530_measure(struct yas5xx *yas5xx, u16 *t, u16 *x, u16 *y1, u16 *y2)
285 {
286 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
287 	unsigned int busy;
288 	u8 data[8];
289 	int ret;
290 	u16 val;
291 
292 	mutex_lock(&yas5xx->lock);
293 	ret = regmap_write(yas5xx->map, YAS530_MEASURE, YAS5XX_MEASURE_START);
294 	if (ret < 0)
295 		goto out_unlock;
296 
297 	/*
298 	 * Typical time to measure 1500 us, max 2000 us so wait min 500 us
299 	 * and at most 20000 us (one magnitude more than the datsheet max)
300 	 * before timeout.
301 	 */
302 	ret = regmap_read_poll_timeout(yas5xx->map, YAS5XX_MEASURE_DATA, busy,
303 				       !(busy & YAS5XX_MEASURE_DATA_BUSY),
304 				       500, 20000);
305 	if (ret) {
306 		dev_err(yas5xx->dev, "timeout waiting for measurement\n");
307 		goto out_unlock;
308 	}
309 
310 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_MEASURE_DATA,
311 			       data, sizeof(data));
312 	if (ret)
313 		goto out_unlock;
314 
315 	mutex_unlock(&yas5xx->lock);
316 
317 	switch (ci->devid) {
318 	case YAS530_DEVICE_ID:
319 		/*
320 		 * The t value is 9 bits in big endian format
321 		 * These are the bits used in a 16bit word:
322 		 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
323 		 *    x  x  x  x  x  x  x  x  x
324 		 */
325 		val = get_unaligned_be16(&data[0]);
326 		val = FIELD_GET(GENMASK(14, 6), val);
327 		*t = val;
328 		*x = yas530_extract_axis(&data[2]);
329 		*y1 = yas530_extract_axis(&data[4]);
330 		*y2 = yas530_extract_axis(&data[6]);
331 		break;
332 	case YAS532_DEVICE_ID:
333 		/*
334 		 * The t value is 10 bits in big endian format
335 		 * These are the bits used in a 16bit word:
336 		 * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
337 		 *    x  x  x  x  x  x  x  x  x  x
338 		 */
339 		val = get_unaligned_be16(&data[0]);
340 		val = FIELD_GET(GENMASK(14, 5), val);
341 		*t = val;
342 		*x = yas532_extract_axis(&data[2]);
343 		*y1 = yas532_extract_axis(&data[4]);
344 		*y2 = yas532_extract_axis(&data[6]);
345 		break;
346 	default:
347 		dev_err(yas5xx->dev, "unknown data format\n");
348 		ret = -EINVAL;
349 		break;
350 	}
351 
352 	return ret;
353 
354 out_unlock:
355 	mutex_unlock(&yas5xx->lock);
356 	return ret;
357 }
358 
359 /**
360  * yas537_measure() - Make a measure from the hardware
361  * @yas5xx: The device state
362  * @t: the raw temperature measurement
363  * @x: the raw x axis measurement
364  * @y1: the y1 axis measurement
365  * @y2: the y2 axis measurement
366  * @return: 0 on success or error code
367  */
368 static int yas537_measure(struct yas5xx *yas5xx, u16 *t, u16 *x, u16 *y1, u16 *y2)
369 {
370 	struct yas5xx_calibration *c = &yas5xx->calibration;
371 	unsigned int busy;
372 	u8 data[8];
373 	u16 xy1y2[3];
374 	s32 h[3], s[3];
375 	int i, ret;
376 
377 	mutex_lock(&yas5xx->lock);
378 
379 	/* Contrary to YAS530/532, also a "cont" bit is set, meaning unknown */
380 	ret = regmap_write(yas5xx->map, YAS537_MEASURE, YAS5XX_MEASURE_START |
381 			   YAS5XX_MEASURE_CONT);
382 	if (ret < 0)
383 		goto out_unlock;
384 
385 	/* Use same timeout like YAS530/532 but the bit is in data row 2 */
386 	ret = regmap_read_poll_timeout(yas5xx->map, YAS5XX_MEASURE_DATA + 2, busy,
387 				       !(busy & YAS5XX_MEASURE_DATA_BUSY),
388 				       500, 20000);
389 	if (ret) {
390 		dev_err(yas5xx->dev, "timeout waiting for measurement\n");
391 		goto out_unlock;
392 	}
393 
394 	ret = regmap_bulk_read(yas5xx->map, YAS5XX_MEASURE_DATA,
395 			       data, sizeof(data));
396 	if (ret)
397 		goto out_unlock;
398 
399 	mutex_unlock(&yas5xx->lock);
400 
401 	*t = get_unaligned_be16(&data[0]);
402 	xy1y2[0] = FIELD_GET(GENMASK(13, 0), get_unaligned_be16(&data[2]));
403 	xy1y2[1] = get_unaligned_be16(&data[4]);
404 	xy1y2[2] = get_unaligned_be16(&data[6]);
405 
406 	/* The second version of YAS537 needs to include calibration coefficients */
407 	if (yas5xx->version == YAS537_VERSION_1) {
408 		for (i = 0; i < 3; i++)
409 			s[i] = xy1y2[i] - BIT(13);
410 		h[0] = (c->k *   (128 * s[0] + c->a2 * s[1] + c->a3 * s[2])) / BIT(13);
411 		h[1] = (c->k * (c->a4 * s[0] + c->a5 * s[1] + c->a6 * s[2])) / BIT(13);
412 		h[2] = (c->k * (c->a7 * s[0] + c->a8 * s[1] + c->a9 * s[2])) / BIT(13);
413 		for (i = 0; i < 3; i++) {
414 			clamp_val(h[i], -BIT(13), BIT(13) - 1);
415 			xy1y2[i] = h[i] + BIT(13);
416 		}
417 	}
418 
419 	*x = xy1y2[0];
420 	*y1 = xy1y2[1];
421 	*y2 = xy1y2[2];
422 
423 	return 0;
424 
425 out_unlock:
426 	mutex_unlock(&yas5xx->lock);
427 	return ret;
428 }
429 
430 /* Used by YAS530, YAS532 and YAS533 */
431 static s32 yas530_linearize(struct yas5xx *yas5xx, u16 val, int axis)
432 {
433 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
434 	struct yas5xx_calibration *c = &yas5xx->calibration;
435 	static const s32 yas532ac_coef[] = {
436 		YAS532_VERSION_AC_COEF_X,
437 		YAS532_VERSION_AC_COEF_Y1,
438 		YAS532_VERSION_AC_COEF_Y2,
439 	};
440 	s32 coef;
441 
442 	/* Select coefficients */
443 	switch (ci->devid) {
444 	case YAS530_DEVICE_ID:
445 		if (yas5xx->version == YAS530_VERSION_A)
446 			coef = YAS530_VERSION_A_COEF;
447 		else
448 			coef = YAS530_VERSION_B_COEF;
449 		break;
450 	case YAS532_DEVICE_ID:
451 		if (yas5xx->version == YAS532_VERSION_AB)
452 			coef = YAS532_VERSION_AB_COEF;
453 		else
454 			/* Elaborate coefficients */
455 			coef = yas532ac_coef[axis];
456 		break;
457 	default:
458 		dev_err(yas5xx->dev, "unknown device type\n");
459 		return val;
460 	}
461 	/*
462 	 * Linearization formula:
463 	 *
464 	 * x' = x - (3721 + 50 * f) + (xoffset - r) * c
465 	 *
466 	 * Where f and r are calibration values, c is a per-device
467 	 * and sometimes per-axis coefficient.
468 	 */
469 	return val - (3721 + 50 * c->f[axis]) +
470 		(yas5xx->hard_offsets[axis] - c->r[axis]) * coef;
471 }
472 
473 static s32 yas5xx_calc_temperature(struct yas5xx *yas5xx, u16 t)
474 {
475 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
476 	s32 to;
477 	u16 t_ref;
478 	s16 min_temp_x10;
479 	int ref_temp_x10;
480 
481 	t_ref = ci->t_ref;
482 	min_temp_x10 = ci->min_temp_x10;
483 	ref_temp_x10 = 200;
484 
485 	to = (min_temp_x10 + ((ref_temp_x10 - min_temp_x10) * t / t_ref)) * 100;
486 	return to;
487 }
488 
489 /**
490  * yas530_get_measure() - Measure a sample of all axis and process
491  * @yas5xx: The device state
492  * @to: Temperature out
493  * @xo: X axis out
494  * @yo: Y axis out
495  * @zo: Z axis out
496  * @return: 0 on success or error code
497  *
498  * Used by YAS530, YAS532 and YAS533.
499  */
500 static int yas530_get_measure(struct yas5xx *yas5xx, s32 *to, s32 *xo, s32 *yo, s32 *zo)
501 {
502 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
503 	struct yas5xx_calibration *c = &yas5xx->calibration;
504 	u16 t_ref, t_comp, t, x, y1, y2;
505 	/* These are signed x, signed y1 etc */
506 	s32 sx, sy1, sy2, sy, sz;
507 	int ret;
508 
509 	/* We first get raw data that needs to be translated to [x,y,z] */
510 	ret = yas530_measure(yas5xx, &t, &x, &y1, &y2);
511 	if (ret)
512 		return ret;
513 
514 	/* Do some linearization if available */
515 	sx = yas530_linearize(yas5xx, x, 0);
516 	sy1 = yas530_linearize(yas5xx, y1, 1);
517 	sy2 = yas530_linearize(yas5xx, y2, 2);
518 
519 	/*
520 	 * Set the temperature for compensation (unit: counts):
521 	 * YAS532/YAS533 version AC uses the temperature deviation as a
522 	 * multiplier. YAS530 and YAS532 version AB use solely the t value.
523 	 */
524 	t_ref = ci->t_ref;
525 	if (ci->devid == YAS532_DEVICE_ID &&
526 	    yas5xx->version == YAS532_VERSION_AC) {
527 		t_comp = t - t_ref;
528 	} else {
529 		t_comp = t;
530 	}
531 
532 	/*
533 	 * Temperature compensation for x, y1, y2 respectively:
534 	 *
535 	 *          Cx * t_comp
536 	 * x' = x - -----------
537 	 *              100
538 	 */
539 	sx = sx - (c->Cx * t_comp) / 100;
540 	sy1 = sy1 - (c->Cy1 * t_comp) / 100;
541 	sy2 = sy2 - (c->Cy2 * t_comp) / 100;
542 
543 	/*
544 	 * Break y1 and y2 into y and z, y1 and y2 are apparently encoding
545 	 * y and z.
546 	 */
547 	sy = sy1 - sy2;
548 	sz = -sy1 - sy2;
549 
550 	/* Calculate temperature readout */
551 	*to = yas5xx_calc_temperature(yas5xx, t);
552 
553 	/*
554 	 * Calibrate [x,y,z] with some formulas like this:
555 	 *
556 	 *            100 * x + a_2 * y + a_3 * z
557 	 *  x' = k *  ---------------------------
558 	 *                        10
559 	 *
560 	 *           a_4 * x + a_5 * y + a_6 * z
561 	 *  y' = k * ---------------------------
562 	 *                        10
563 	 *
564 	 *           a_7 * x + a_8 * y + a_9 * z
565 	 *  z' = k * ---------------------------
566 	 *                        10
567 	 */
568 	*xo = c->k * ((100 * sx + c->a2 * sy + c->a3 * sz) / 10);
569 	*yo = c->k * ((c->a4 * sx + c->a5 * sy + c->a6 * sz) / 10);
570 	*zo = c->k * ((c->a7 * sx + c->a8 * sy + c->a9 * sz) / 10);
571 
572 	return 0;
573 }
574 
575 /**
576  * yas537_get_measure() - Measure a sample of all axis and process
577  * @yas5xx: The device state
578  * @to: Temperature out
579  * @xo: X axis out
580  * @yo: Y axis out
581  * @zo: Z axis out
582  * @return: 0 on success or error code
583  */
584 static int yas537_get_measure(struct yas5xx *yas5xx, s32 *to, s32 *xo, s32 *yo, s32 *zo)
585 {
586 	u16 t, x, y1, y2;
587 	int ret;
588 
589 	/* We first get raw data that needs to be translated to [x,y,z] */
590 	ret = yas537_measure(yas5xx, &t, &x, &y1, &y2);
591 	if (ret)
592 		return ret;
593 
594 	/* Calculate temperature readout */
595 	*to = yas5xx_calc_temperature(yas5xx, t);
596 
597 	/*
598 	 * Unfortunately, no linearization or temperature compensation formulas
599 	 * are known for YAS537.
600 	 */
601 
602 	/* Calculate x, y, z from x, y1, y2 */
603 	*xo = (x - BIT(13)) * 300;
604 	*yo = (y1 - y2) * 1732 / 10;
605 	*zo = (-y1 - y2 + BIT(14)) * 300;
606 
607 	return 0;
608 }
609 
610 static int yas5xx_read_raw(struct iio_dev *indio_dev,
611 			   struct iio_chan_spec const *chan,
612 			   int *val, int *val2,
613 			   long mask)
614 {
615 	struct yas5xx *yas5xx = iio_priv(indio_dev);
616 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
617 	s32 t, x, y, z;
618 	int ret;
619 
620 	switch (mask) {
621 	case IIO_CHAN_INFO_PROCESSED:
622 	case IIO_CHAN_INFO_RAW:
623 		pm_runtime_get_sync(yas5xx->dev);
624 		ret = ci->get_measure(yas5xx, &t, &x, &y, &z);
625 		pm_runtime_mark_last_busy(yas5xx->dev);
626 		pm_runtime_put_autosuspend(yas5xx->dev);
627 		if (ret)
628 			return ret;
629 		switch (chan->address) {
630 		case 0:
631 			*val = t;
632 			break;
633 		case 1:
634 			*val = x;
635 			break;
636 		case 2:
637 			*val = y;
638 			break;
639 		case 3:
640 			*val = z;
641 			break;
642 		default:
643 			dev_err(yas5xx->dev, "unknown channel\n");
644 			return -EINVAL;
645 		}
646 		return IIO_VAL_INT;
647 	case IIO_CHAN_INFO_SCALE:
648 		*val = 1;
649 		*val2 = ci->scaling_val2;
650 		return IIO_VAL_FRACTIONAL;
651 	default:
652 		/* Unknown request */
653 		return -EINVAL;
654 	}
655 }
656 
657 static void yas5xx_fill_buffer(struct iio_dev *indio_dev)
658 {
659 	struct yas5xx *yas5xx = iio_priv(indio_dev);
660 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
661 	s32 t, x, y, z;
662 	int ret;
663 
664 	pm_runtime_get_sync(yas5xx->dev);
665 	ret = ci->get_measure(yas5xx, &t, &x, &y, &z);
666 	pm_runtime_mark_last_busy(yas5xx->dev);
667 	pm_runtime_put_autosuspend(yas5xx->dev);
668 	if (ret) {
669 		dev_err(yas5xx->dev, "error refilling buffer\n");
670 		return;
671 	}
672 	yas5xx->scan.channels[0] = t;
673 	yas5xx->scan.channels[1] = x;
674 	yas5xx->scan.channels[2] = y;
675 	yas5xx->scan.channels[3] = z;
676 	iio_push_to_buffers_with_timestamp(indio_dev, &yas5xx->scan,
677 					   iio_get_time_ns(indio_dev));
678 }
679 
680 static irqreturn_t yas5xx_handle_trigger(int irq, void *p)
681 {
682 	const struct iio_poll_func *pf = p;
683 	struct iio_dev *indio_dev = pf->indio_dev;
684 
685 	yas5xx_fill_buffer(indio_dev);
686 	iio_trigger_notify_done(indio_dev->trig);
687 
688 	return IRQ_HANDLED;
689 }
690 
691 
692 static const struct iio_mount_matrix *
693 yas5xx_get_mount_matrix(const struct iio_dev *indio_dev,
694 			const struct iio_chan_spec *chan)
695 {
696 	struct yas5xx *yas5xx = iio_priv(indio_dev);
697 
698 	return &yas5xx->orientation;
699 }
700 
701 static const struct iio_chan_spec_ext_info yas5xx_ext_info[] = {
702 	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, yas5xx_get_mount_matrix),
703 	{ }
704 };
705 
706 #define YAS5XX_AXIS_CHANNEL(axis, index)				\
707 	{								\
708 		.type = IIO_MAGN,					\
709 		.modified = 1,						\
710 		.channel2 = IIO_MOD_##axis,				\
711 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		\
712 			BIT(IIO_CHAN_INFO_SCALE),			\
713 		.ext_info = yas5xx_ext_info,				\
714 		.address = index,					\
715 		.scan_index = index,					\
716 		.scan_type = {						\
717 			.sign = 's',					\
718 			.realbits = 32,					\
719 			.storagebits = 32,				\
720 			.endianness = IIO_CPU,				\
721 		},							\
722 	}
723 
724 static const struct iio_chan_spec yas5xx_channels[] = {
725 	{
726 		.type = IIO_TEMP,
727 		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
728 		.address = 0,
729 		.scan_index = 0,
730 		.scan_type = {
731 			.sign = 's',
732 			.realbits = 32,
733 			.storagebits = 32,
734 			.endianness = IIO_CPU,
735 		},
736 	},
737 	YAS5XX_AXIS_CHANNEL(X, 1),
738 	YAS5XX_AXIS_CHANNEL(Y, 2),
739 	YAS5XX_AXIS_CHANNEL(Z, 3),
740 	IIO_CHAN_SOFT_TIMESTAMP(4),
741 };
742 
743 static const unsigned long yas5xx_scan_masks[] = { GENMASK(3, 0), 0 };
744 
745 static const struct iio_info yas5xx_info = {
746 	.read_raw = &yas5xx_read_raw,
747 };
748 
749 static bool yas5xx_volatile_reg(struct device *dev, unsigned int reg)
750 {
751 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
752 	struct yas5xx *yas5xx = iio_priv(indio_dev);
753 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
754 	int reg_qty;
755 	int i;
756 
757 	if (reg >= YAS5XX_MEASURE_DATA && reg < YAS5XX_MEASURE_DATA + 8)
758 		return true;
759 
760 	/*
761 	 * YAS versions share different registers on the same address,
762 	 * need to differentiate.
763 	 */
764 	reg_qty = ci->volatile_reg_qty;
765 	for (i = 0; i < reg_qty; i++) {
766 		if (reg == ci->volatile_reg[i])
767 			return true;
768 	}
769 
770 	return false;
771 }
772 
773 /* TODO: enable regmap cache, using mark dirty and sync at runtime resume */
774 static const struct regmap_config yas5xx_regmap_config = {
775 	.reg_bits = 8,
776 	.val_bits = 8,
777 	.max_register = 0xff,
778 	.volatile_reg = yas5xx_volatile_reg,
779 };
780 
781 /**
782  * yas530_extract_calibration() - extracts the a2-a9 and k calibration
783  * @data: the bitfield to use
784  * @c: the calibration to populate
785  *
786  * Used by YAS530, YAS532 and YAS533.
787  */
788 static void yas530_extract_calibration(u8 *data, struct yas5xx_calibration *c)
789 {
790 	u64 val = get_unaligned_be64(data);
791 
792 	/*
793 	 * Bitfield layout for the axis calibration data, for factor
794 	 * a2 = 2 etc, k = k, c = clock divider
795 	 *
796 	 * n   7 6 5 4 3 2 1 0
797 	 * 0 [ 2 2 2 2 2 2 3 3 ] bits 63 .. 56
798 	 * 1 [ 3 3 4 4 4 4 4 4 ] bits 55 .. 48
799 	 * 2 [ 5 5 5 5 5 5 6 6 ] bits 47 .. 40
800 	 * 3 [ 6 6 6 6 7 7 7 7 ] bits 39 .. 32
801 	 * 4 [ 7 7 7 8 8 8 8 8 ] bits 31 .. 24
802 	 * 5 [ 8 9 9 9 9 9 9 9 ] bits 23 .. 16
803 	 * 6 [ 9 k k k k k c c ] bits 15 .. 8
804 	 * 7 [ c x x x x x x x ] bits  7 .. 0
805 	 */
806 	c->a2 = FIELD_GET(GENMASK_ULL(63, 58), val) - 32;
807 	c->a3 = FIELD_GET(GENMASK_ULL(57, 54), val) - 8;
808 	c->a4 = FIELD_GET(GENMASK_ULL(53, 48), val) - 32;
809 	c->a5 = FIELD_GET(GENMASK_ULL(47, 42), val) + 38;
810 	c->a6 = FIELD_GET(GENMASK_ULL(41, 36), val) - 32;
811 	c->a7 = FIELD_GET(GENMASK_ULL(35, 29), val) - 64;
812 	c->a8 = FIELD_GET(GENMASK_ULL(28, 23), val) - 32;
813 	c->a9 = FIELD_GET(GENMASK_ULL(22, 15), val);
814 	c->k = FIELD_GET(GENMASK_ULL(14, 10), val) + 10;
815 	c->dck = FIELD_GET(GENMASK_ULL(9, 7), val);
816 }
817 
818 static int yas530_get_calibration_data(struct yas5xx *yas5xx)
819 {
820 	struct yas5xx_calibration *c = &yas5xx->calibration;
821 	u8 data[16];
822 	u32 val;
823 	int ret;
824 
825 	/* Dummy read, first read is ALWAYS wrong */
826 	ret = regmap_bulk_read(yas5xx->map, YAS530_CAL, data, sizeof(data));
827 	if (ret)
828 		return ret;
829 
830 	/* Actual calibration readout */
831 	ret = regmap_bulk_read(yas5xx->map, YAS530_CAL, data, sizeof(data));
832 	if (ret)
833 		return ret;
834 	dev_dbg(yas5xx->dev, "calibration data: %16ph\n", data);
835 
836 	/* Contribute calibration data to the input pool for kernel entropy */
837 	add_device_randomness(data, sizeof(data));
838 
839 	/* Extract version */
840 	yas5xx->version = data[15] & GENMASK(1, 0);
841 
842 	/* Extract the calibration from the bitfield */
843 	c->Cx = data[0] * 6 - 768;
844 	c->Cy1 = data[1] * 6 - 768;
845 	c->Cy2 = data[2] * 6 - 768;
846 	yas530_extract_calibration(&data[3], c);
847 
848 	/*
849 	 * Extract linearization:
850 	 * Linearization layout in the 32 bits at byte 11:
851 	 * The r factors are 6 bit values where bit 5 is the sign
852 	 *
853 	 * n    7  6  5  4  3  2  1  0
854 	 * 0 [ xx xx xx r0 r0 r0 r0 r0 ] bits 31 .. 24
855 	 * 1 [ r0 f0 f0 r1 r1 r1 r1 r1 ] bits 23 .. 16
856 	 * 2 [ r1 f1 f1 r2 r2 r2 r2 r2 ] bits 15 .. 8
857 	 * 3 [ r2 f2 f2 xx xx xx xx xx ] bits  7 .. 0
858 	 */
859 	val = get_unaligned_be32(&data[11]);
860 	c->f[0] = FIELD_GET(GENMASK(22, 21), val);
861 	c->f[1] = FIELD_GET(GENMASK(14, 13), val);
862 	c->f[2] = FIELD_GET(GENMASK(6, 5), val);
863 	c->r[0] = sign_extend32(FIELD_GET(GENMASK(28, 23), val), 5);
864 	c->r[1] = sign_extend32(FIELD_GET(GENMASK(20, 15), val), 5);
865 	c->r[2] = sign_extend32(FIELD_GET(GENMASK(12, 7), val), 5);
866 
867 	return 0;
868 }
869 
870 static int yas532_get_calibration_data(struct yas5xx *yas5xx)
871 {
872 	struct yas5xx_calibration *c = &yas5xx->calibration;
873 	u8 data[14];
874 	u32 val;
875 	int ret;
876 
877 	/* Dummy read, first read is ALWAYS wrong */
878 	ret = regmap_bulk_read(yas5xx->map, YAS530_CAL, data, sizeof(data));
879 	if (ret)
880 		return ret;
881 	/* Actual calibration readout */
882 	ret = regmap_bulk_read(yas5xx->map, YAS530_CAL, data, sizeof(data));
883 	if (ret)
884 		return ret;
885 	dev_dbg(yas5xx->dev, "calibration data: %14ph\n", data);
886 
887 	/* Sanity check, is this all zeroes? */
888 	if (!memchr_inv(data, 0x00, 13) && !(data[13] & BIT(7)))
889 		dev_warn(yas5xx->dev, "calibration is blank!\n");
890 
891 	/* Contribute calibration data to the input pool for kernel entropy */
892 	add_device_randomness(data, sizeof(data));
893 
894 	/* Only one bit of version info reserved here as far as we know */
895 	yas5xx->version = data[13] & BIT(0);
896 
897 	/* Extract calibration from the bitfield */
898 	c->Cx = data[0] * 10 - 1280;
899 	c->Cy1 = data[1] * 10 - 1280;
900 	c->Cy2 = data[2] * 10 - 1280;
901 	yas530_extract_calibration(&data[3], c);
902 
903 	/*
904 	 * Extract linearization:
905 	 * Linearization layout in the 32 bits at byte 10:
906 	 * The r factors are 6 bit values where bit 5 is the sign
907 	 *
908 	 * n    7  6  5  4  3  2  1  0
909 	 * 0 [ xx r0 r0 r0 r0 r0 r0 f0 ] bits 31 .. 24
910 	 * 1 [ f0 r1 r1 r1 r1 r1 r1 f1 ] bits 23 .. 16
911 	 * 2 [ f1 r2 r2 r2 r2 r2 r2 f2 ] bits 15 .. 8
912 	 * 3 [ f2 xx xx xx xx xx xx xx ] bits  7 .. 0
913 	 */
914 	val = get_unaligned_be32(&data[10]);
915 	c->f[0] = FIELD_GET(GENMASK(24, 23), val);
916 	c->f[1] = FIELD_GET(GENMASK(16, 15), val);
917 	c->f[2] = FIELD_GET(GENMASK(8, 7), val);
918 	c->r[0] = sign_extend32(FIELD_GET(GENMASK(30, 25), val), 5);
919 	c->r[1] = sign_extend32(FIELD_GET(GENMASK(22, 17), val), 5);
920 	c->r[2] = sign_extend32(FIELD_GET(GENMASK(14, 7), val), 5);
921 
922 	return 0;
923 }
924 
925 static int yas537_get_calibration_data(struct yas5xx *yas5xx)
926 {
927 	struct yas5xx_calibration *c = &yas5xx->calibration;
928 	u8 data[17];
929 	u32 val1, val2, val3, val4;
930 	int i, ret;
931 
932 	/* Writing SRST register */
933 	ret = regmap_write(yas5xx->map, YAS537_SRST, BIT(1));
934 	if (ret)
935 		return ret;
936 
937 	/* Calibration readout, YAS537 needs one readout only */
938 	ret = regmap_bulk_read(yas5xx->map, YAS537_CAL, data, sizeof(data));
939 	if (ret)
940 		return ret;
941 	dev_dbg(yas5xx->dev, "calibration data: %17ph\n", data);
942 
943 	/* Sanity check, is this all zeroes? */
944 	if (!memchr_inv(data, 0x00, 16) && !FIELD_GET(GENMASK(5, 0), data[16]))
945 		dev_warn(yas5xx->dev, "calibration is blank!\n");
946 
947 	/* Contribute calibration data to the input pool for kernel entropy */
948 	add_device_randomness(data, sizeof(data));
949 
950 	/* Extract version information */
951 	yas5xx->version = FIELD_GET(GENMASK(7, 6), data[16]);
952 
953 	/* There are two versions of YAS537 behaving differently */
954 	switch (yas5xx->version) {
955 	case YAS537_VERSION_0:
956 		/*
957 		 * The first version simply writes data back into registers:
958 		 *
959 		 * data[0]  YAS537_MTC		0x93
960 		 * data[1]			0x94
961 		 * data[2]			0x95
962 		 * data[3]			0x96
963 		 * data[4]			0x97
964 		 * data[5]			0x98
965 		 * data[6]			0x99
966 		 * data[7]			0x9a
967 		 * data[8]			0x9b
968 		 * data[9]			0x9c
969 		 * data[10]			0x9d
970 		 * data[11] YAS537_OC		0x9e
971 		 *
972 		 * data[12] YAS537_OFFSET_X	0x84
973 		 * data[13] YAS537_OFFSET_Y1	0x85
974 		 * data[14] YAS537_OFFSET_Y2	0x86
975 		 *
976 		 * data[15] YAS537_HCK		0x88
977 		 * data[16] YAS537_LCK		0x89
978 		 */
979 		for (i = 0; i < 12; i++) {
980 			ret = regmap_write(yas5xx->map, YAS537_MTC + i,
981 					   data[i]);
982 			if (ret)
983 				return ret;
984 		}
985 		for (i = 0; i < 3; i++) {
986 			ret = regmap_write(yas5xx->map, YAS537_OFFSET_X + i,
987 					   data[i + 12]);
988 			if (ret)
989 				return ret;
990 			yas5xx->hard_offsets[i] = data[i + 12];
991 		}
992 		for (i = 0; i < 2; i++) {
993 			ret = regmap_write(yas5xx->map, YAS537_HCK + i,
994 					   data[i + 15]);
995 			if (ret)
996 				return ret;
997 		}
998 		break;
999 	case YAS537_VERSION_1:
1000 		/*
1001 		 * The second version writes some data into registers but also
1002 		 * extracts calibration coefficients.
1003 		 *
1004 		 * Registers being written:
1005 		 *
1006 		 * data[0]  YAS537_MTC			0x93
1007 		 * data[1]  YAS537_MTC+1		0x94
1008 		 * data[2]  YAS537_MTC+2		0x95
1009 		 * data[3]  YAS537_MTC+3 (partially)	0x96
1010 		 *
1011 		 * data[12] YAS537_OFFSET_X		0x84
1012 		 * data[13] YAS537_OFFSET_Y1		0x85
1013 		 * data[14] YAS537_OFFSET_Y2		0x86
1014 		 *
1015 		 * data[15] YAS537_HCK (partially)	0x88
1016 		 *          YAS537_LCK (partially)	0x89
1017 		 * data[16] YAS537_OC  (partially)	0x9e
1018 		 */
1019 		for (i = 0; i < 3; i++) {
1020 			ret = regmap_write(yas5xx->map, YAS537_MTC + i,
1021 					   data[i]);
1022 			if (ret)
1023 				return ret;
1024 		}
1025 		for (i = 0; i < 3; i++) {
1026 			ret = regmap_write(yas5xx->map, YAS537_OFFSET_X + i,
1027 					   data[i + 12]);
1028 			if (ret)
1029 				return ret;
1030 			yas5xx->hard_offsets[i] = data[i + 12];
1031 		}
1032 		/*
1033 		 * Visualization of partially taken data:
1034 		 *
1035 		 * data[3]       n 7 6 5 4 3 2 1 0
1036 		 * YAS537_MTC+3    x x x 1 0 0 0 0
1037 		 *
1038 		 * data[15]      n 7 6 5 4 3 2 1 0
1039 		 * YAS537_HCK      x x x x 0
1040 		 *
1041 		 * data[15]      n 7 6 5 4 3 2 1 0
1042 		 * YAS537_LCK              x x x x 0
1043 		 *
1044 		 * data[16]      n 7 6 5 4 3 2 1 0
1045 		 * YAS537_OC           x x x x x x
1046 		 */
1047 		ret = regmap_write(yas5xx->map, YAS537_MTC + 3,
1048 				   FIELD_PREP(YAS537_MTC3_MASK_PREP,
1049 				   FIELD_GET(YAS537_MTC3_MASK_GET, data[3])) |
1050 				   YAS537_MTC3_ADD_BIT);
1051 		if (ret)
1052 			return ret;
1053 		ret = regmap_write(yas5xx->map, YAS537_HCK,
1054 				   FIELD_PREP(YAS537_HCK_MASK_PREP,
1055 				   FIELD_GET(YAS537_HCK_MASK_GET, data[15])));
1056 		if (ret)
1057 			return ret;
1058 		ret = regmap_write(yas5xx->map, YAS537_LCK,
1059 				   FIELD_PREP(YAS537_LCK_MASK_PREP,
1060 				   FIELD_GET(YAS537_LCK_MASK_GET, data[15])));
1061 		if (ret)
1062 			return ret;
1063 		ret = regmap_write(yas5xx->map, YAS537_OC,
1064 				   FIELD_GET(YAS537_OC_MASK_GET, data[16]));
1065 		if (ret)
1066 			return ret;
1067 		/*
1068 		 * For data extraction, build some blocks. Four 32-bit blocks
1069 		 * look appropriate.
1070 		 *
1071 		 *            n    7  6  5  4  3  2  1  0
1072 		 *  data[0]   0 [ Cx Cx Cx Cx Cx Cx Cx Cx ] bits 31 .. 24
1073 		 *  data[1]   1 [ Cx C1 C1 C1 C1 C1 C1 C1 ] bits 23 .. 16
1074 		 *  data[2]   2 [ C1 C1 C2 C2 C2 C2 C2 C2 ] bits 15 .. 8
1075 		 *  data[3]   3 [ C2 C2 C2                ] bits  7 .. 0
1076 		 *
1077 		 *            n    7  6  5  4  3  2  1  0
1078 		 *  data[3]   0 [          a2 a2 a2 a2 a2 ] bits 31 .. 24
1079 		 *  data[4]   1 [ a2 a2 a3 a3 a3 a3 a3 a3 ] bits 23 .. 16
1080 		 *  data[5]   2 [ a3 a4 a4 a4 a4 a4 a4 a4 ] bits 15 .. 8
1081 		 *  data[6]   3 [ a4                      ] bits  7 .. 0
1082 		 *
1083 		 *            n    7  6  5  4  3  2  1  0
1084 		 *  data[6]   0 [    a5 a5 a5 a5 a5 a5 a5 ] bits 31 .. 24
1085 		 *  data[7]   1 [ a5 a5 a6 a6 a6 a6 a6 a6 ] bits 23 .. 16
1086 		 *  data[8]   2 [ a6 a7 a7 a7 a7 a7 a7 a7 ] bits 15 .. 8
1087 		 *  data[9]   3 [ a7                      ] bits  7 .. 0
1088 		 *
1089 		 *            n    7  6  5  4  3  2  1  0
1090 		 *  data[9]   0 [    a8 a8 a8 a8 a8 a8 a8 ] bits 31 .. 24
1091 		 *  data[10]  1 [ a9 a9 a9 a9 a9 a9 a9 a9 ] bits 23 .. 16
1092 		 *  data[11]  2 [ a9  k  k  k  k  k  k  k ] bits 15 .. 8
1093 		 *  data[12]  3 [                         ] bits  7 .. 0
1094 		 */
1095 		val1 = get_unaligned_be32(&data[0]);
1096 		val2 = get_unaligned_be32(&data[3]);
1097 		val3 = get_unaligned_be32(&data[6]);
1098 		val4 = get_unaligned_be32(&data[9]);
1099 		/* Extract calibration coefficients and modify */
1100 		c->Cx  = FIELD_GET(GENMASK(31, 23), val1) - 256;
1101 		c->Cy1 = FIELD_GET(GENMASK(22, 14), val1) - 256;
1102 		c->Cy2 = FIELD_GET(GENMASK(13,  5), val1) - 256;
1103 		c->a2  = FIELD_GET(GENMASK(28, 22), val2) -  64;
1104 		c->a3  = FIELD_GET(GENMASK(21, 15), val2) -  64;
1105 		c->a4  = FIELD_GET(GENMASK(14,  7), val2) - 128;
1106 		c->a5  = FIELD_GET(GENMASK(30, 22), val3) - 112;
1107 		c->a6  = FIELD_GET(GENMASK(21, 15), val3) -  64;
1108 		c->a7  = FIELD_GET(GENMASK(14,  7), val3) - 128;
1109 		c->a8  = FIELD_GET(GENMASK(30, 24), val4) -  64;
1110 		c->a9  = FIELD_GET(GENMASK(23, 15), val4) - 112;
1111 		c->k   = FIELD_GET(GENMASK(14,  8), val4);
1112 		break;
1113 	default:
1114 		dev_err(yas5xx->dev, "unknown version of YAS537\n");
1115 		return -EINVAL;
1116 	}
1117 
1118 	return 0;
1119 }
1120 
1121 /* Used by YAS530, YAS532 and YAS533 */
1122 static void yas530_dump_calibration(struct yas5xx *yas5xx)
1123 {
1124 	struct yas5xx_calibration *c = &yas5xx->calibration;
1125 
1126 	dev_dbg(yas5xx->dev, "f[] = [%d, %d, %d]\n",
1127 		c->f[0], c->f[1], c->f[2]);
1128 	dev_dbg(yas5xx->dev, "r[] = [%d, %d, %d]\n",
1129 		c->r[0], c->r[1], c->r[2]);
1130 	dev_dbg(yas5xx->dev, "Cx = %d\n", c->Cx);
1131 	dev_dbg(yas5xx->dev, "Cy1 = %d\n", c->Cy1);
1132 	dev_dbg(yas5xx->dev, "Cy2 = %d\n", c->Cy2);
1133 	dev_dbg(yas5xx->dev, "a2 = %d\n", c->a2);
1134 	dev_dbg(yas5xx->dev, "a3 = %d\n", c->a3);
1135 	dev_dbg(yas5xx->dev, "a4 = %d\n", c->a4);
1136 	dev_dbg(yas5xx->dev, "a5 = %d\n", c->a5);
1137 	dev_dbg(yas5xx->dev, "a6 = %d\n", c->a6);
1138 	dev_dbg(yas5xx->dev, "a7 = %d\n", c->a7);
1139 	dev_dbg(yas5xx->dev, "a8 = %d\n", c->a8);
1140 	dev_dbg(yas5xx->dev, "a9 = %d\n", c->a9);
1141 	dev_dbg(yas5xx->dev, "k = %d\n", c->k);
1142 	dev_dbg(yas5xx->dev, "dck = %d\n", c->dck);
1143 }
1144 
1145 static void yas537_dump_calibration(struct yas5xx *yas5xx)
1146 {
1147 	struct yas5xx_calibration *c = &yas5xx->calibration;
1148 
1149 	if (yas5xx->version == YAS537_VERSION_1) {
1150 		dev_dbg(yas5xx->dev, "Cx = %d\n", c->Cx);
1151 		dev_dbg(yas5xx->dev, "Cy1 = %d\n", c->Cy1);
1152 		dev_dbg(yas5xx->dev, "Cy2 = %d\n", c->Cy2);
1153 		dev_dbg(yas5xx->dev, "a2 = %d\n", c->a2);
1154 		dev_dbg(yas5xx->dev, "a3 = %d\n", c->a3);
1155 		dev_dbg(yas5xx->dev, "a4 = %d\n", c->a4);
1156 		dev_dbg(yas5xx->dev, "a5 = %d\n", c->a5);
1157 		dev_dbg(yas5xx->dev, "a6 = %d\n", c->a6);
1158 		dev_dbg(yas5xx->dev, "a7 = %d\n", c->a7);
1159 		dev_dbg(yas5xx->dev, "a8 = %d\n", c->a8);
1160 		dev_dbg(yas5xx->dev, "a9 = %d\n", c->a9);
1161 		dev_dbg(yas5xx->dev, "k = %d\n", c->k);
1162 	}
1163 }
1164 
1165 /* Used by YAS530, YAS532 and YAS533 */
1166 static int yas530_set_offsets(struct yas5xx *yas5xx, s8 ox, s8 oy1, s8 oy2)
1167 {
1168 	int ret;
1169 
1170 	ret = regmap_write(yas5xx->map, YAS530_OFFSET_X, ox);
1171 	if (ret)
1172 		return ret;
1173 	ret = regmap_write(yas5xx->map, YAS530_OFFSET_Y1, oy1);
1174 	if (ret)
1175 		return ret;
1176 	return regmap_write(yas5xx->map, YAS530_OFFSET_Y2, oy2);
1177 }
1178 
1179 /* Used by YAS530, YAS532 and YAS533 */
1180 static s8 yas530_adjust_offset(s8 old, int bit, u16 center, u16 measure)
1181 {
1182 	if (measure > center)
1183 		return old + BIT(bit);
1184 	if (measure < center)
1185 		return old - BIT(bit);
1186 	return old;
1187 }
1188 
1189 /* Used by YAS530, YAS532 and YAS533 */
1190 static int yas530_measure_offsets(struct yas5xx *yas5xx)
1191 {
1192 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
1193 	int ret;
1194 	u16 center;
1195 	u16 t, x, y1, y2;
1196 	s8 ox, oy1, oy2;
1197 	int i;
1198 
1199 	/* Actuate the init coil and measure offsets */
1200 	ret = regmap_write(yas5xx->map, YAS530_ACTUATE_INIT_COIL, 0);
1201 	if (ret)
1202 		return ret;
1203 
1204 	/* When the initcoil is active this should be around the center */
1205 	switch (ci->devid) {
1206 	case YAS530_DEVICE_ID:
1207 		center = YAS530_DATA_CENTER;
1208 		break;
1209 	case YAS532_DEVICE_ID:
1210 		center = YAS532_DATA_CENTER;
1211 		break;
1212 	default:
1213 		dev_err(yas5xx->dev, "unknown device type\n");
1214 		return -EINVAL;
1215 	}
1216 
1217 	/*
1218 	 * We set offsets in the interval +-31 by iterating
1219 	 * +-16, +-8, +-4, +-2, +-1 adjusting the offsets each
1220 	 * time, then writing the final offsets into the
1221 	 * registers.
1222 	 *
1223 	 * NOTE: these offsets are NOT in the same unit or magnitude
1224 	 * as the values for [x, y1, y2]. The value is +/-31
1225 	 * but the effect on the raw values is much larger.
1226 	 * The effect of the offset is to bring the measure
1227 	 * rougly to the center.
1228 	 */
1229 	ox = 0;
1230 	oy1 = 0;
1231 	oy2 = 0;
1232 
1233 	for (i = 4; i >= 0; i--) {
1234 		ret = yas530_set_offsets(yas5xx, ox, oy1, oy2);
1235 		if (ret)
1236 			return ret;
1237 
1238 		ret = yas530_measure(yas5xx, &t, &x, &y1, &y2);
1239 		if (ret)
1240 			return ret;
1241 		dev_dbg(yas5xx->dev, "measurement %d: x=%d, y1=%d, y2=%d\n",
1242 			5-i, x, y1, y2);
1243 
1244 		ox = yas530_adjust_offset(ox, i, center, x);
1245 		oy1 = yas530_adjust_offset(oy1, i, center, y1);
1246 		oy2 = yas530_adjust_offset(oy2, i, center, y2);
1247 	}
1248 
1249 	/* Needed for calibration algorithm */
1250 	yas5xx->hard_offsets[0] = ox;
1251 	yas5xx->hard_offsets[1] = oy1;
1252 	yas5xx->hard_offsets[2] = oy2;
1253 	ret = yas530_set_offsets(yas5xx, ox, oy1, oy2);
1254 	if (ret)
1255 		return ret;
1256 
1257 	dev_info(yas5xx->dev, "discovered hard offsets: x=%d, y1=%d, y2=%d\n",
1258 		 ox, oy1, oy2);
1259 	return 0;
1260 }
1261 
1262 /* Used by YAS530, YAS532 and YAS533 */
1263 static int yas530_power_on(struct yas5xx *yas5xx)
1264 {
1265 	unsigned int val;
1266 	int ret;
1267 
1268 	/* Zero the test registers */
1269 	ret = regmap_write(yas5xx->map, YAS530_TEST1, 0);
1270 	if (ret)
1271 		return ret;
1272 	ret = regmap_write(yas5xx->map, YAS530_TEST2, 0);
1273 	if (ret)
1274 		return ret;
1275 
1276 	/* Set up for no interrupts, calibrated clock divider */
1277 	val = FIELD_PREP(YAS5XX_CONFIG_CCK_MASK, yas5xx->calibration.dck);
1278 	ret = regmap_write(yas5xx->map, YAS530_CONFIG, val);
1279 	if (ret)
1280 		return ret;
1281 
1282 	/* Measure interval 0 (back-to-back?)  */
1283 	return regmap_write(yas5xx->map, YAS530_MEASURE_INTERVAL, 0);
1284 }
1285 
1286 static int yas537_power_on(struct yas5xx *yas5xx)
1287 {
1288 	__be16 buf;
1289 	int ret;
1290 	u8 intrvl;
1291 
1292 	/* Writing ADCCAL and TRM registers */
1293 	buf = cpu_to_be16(GENMASK(9, 3));
1294 	ret = regmap_bulk_write(yas5xx->map, YAS537_ADCCAL, &buf, sizeof(buf));
1295 	if (ret)
1296 		return ret;
1297 	ret = regmap_write(yas5xx->map, YAS537_TRM, GENMASK(7, 0));
1298 	if (ret)
1299 		return ret;
1300 
1301 	/* The interval value is static in regular operation */
1302 	intrvl = (YAS537_DEFAULT_SENSOR_DELAY_MS * MILLI
1303 		 - YAS537_MEASURE_TIME_WORST_US) / 4100;
1304 	ret = regmap_write(yas5xx->map, YAS537_MEASURE_INTERVAL, intrvl);
1305 	if (ret)
1306 		return ret;
1307 
1308 	/* The average value is also static in regular operation */
1309 	ret = regmap_write(yas5xx->map, YAS537_AVR, YAS537_MAG_AVERAGE_32_MASK);
1310 	if (ret)
1311 		return ret;
1312 
1313 	/* Perform the "rcoil" part but skip the "last_after_rcoil" read */
1314 	ret = regmap_write(yas5xx->map, YAS537_CONFIG, BIT(3));
1315 	if (ret)
1316 		return ret;
1317 
1318 	/* Wait until the coil has ramped up */
1319 	usleep_range(YAS537_MAG_RCOIL_TIME_US, YAS537_MAG_RCOIL_TIME_US + 100);
1320 
1321 	return 0;
1322 }
1323 
1324 static const struct yas5xx_chip_info yas5xx_chip_info_tbl[] = {
1325 	[yas530] = {
1326 		.devid = YAS530_DEVICE_ID,
1327 		.product_name = "YAS530 MS-3E",
1328 		.version_names = { "A", "B" },
1329 		.volatile_reg = yas530_volatile_reg,
1330 		.volatile_reg_qty = ARRAY_SIZE(yas530_volatile_reg),
1331 		.scaling_val2 = 100000000, /* picotesla to Gauss */
1332 		.t_ref = 182, /* counts */
1333 		.min_temp_x10 = -620, /* 1/10:s degrees Celsius */
1334 		.get_measure = yas530_get_measure,
1335 		.get_calibration_data = yas530_get_calibration_data,
1336 		.dump_calibration = yas530_dump_calibration,
1337 		.measure_offsets = yas530_measure_offsets,
1338 		.power_on = yas530_power_on,
1339 	},
1340 	[yas532] = {
1341 		.devid = YAS532_DEVICE_ID,
1342 		.product_name = "YAS532 MS-3R",
1343 		.version_names = { "AB", "AC" },
1344 		.volatile_reg = yas530_volatile_reg,
1345 		.volatile_reg_qty = ARRAY_SIZE(yas530_volatile_reg),
1346 		.scaling_val2 = 100000, /* nanotesla to Gauss */
1347 		.t_ref = 390, /* counts */
1348 		.min_temp_x10 = -500, /* 1/10:s degrees Celsius */
1349 		.get_measure = yas530_get_measure,
1350 		.get_calibration_data = yas532_get_calibration_data,
1351 		.dump_calibration = yas530_dump_calibration,
1352 		.measure_offsets = yas530_measure_offsets,
1353 		.power_on = yas530_power_on,
1354 	},
1355 	[yas533] = {
1356 		.devid = YAS532_DEVICE_ID,
1357 		.product_name = "YAS533 MS-3F",
1358 		.version_names = { "AB", "AC" },
1359 		.volatile_reg = yas530_volatile_reg,
1360 		.volatile_reg_qty = ARRAY_SIZE(yas530_volatile_reg),
1361 		.scaling_val2 = 100000, /* nanotesla to Gauss */
1362 		.t_ref = 390, /* counts */
1363 		.min_temp_x10 = -500, /* 1/10:s degrees Celsius */
1364 		.get_measure = yas530_get_measure,
1365 		.get_calibration_data = yas532_get_calibration_data,
1366 		.dump_calibration = yas530_dump_calibration,
1367 		.measure_offsets = yas530_measure_offsets,
1368 		.power_on = yas530_power_on,
1369 	},
1370 	[yas537] = {
1371 		.devid = YAS537_DEVICE_ID,
1372 		.product_name = "YAS537 MS-3T",
1373 		.version_names = { "v0", "v1" }, /* version naming unknown */
1374 		.volatile_reg = yas537_volatile_reg,
1375 		.volatile_reg_qty = ARRAY_SIZE(yas537_volatile_reg),
1376 		.scaling_val2 = 100000, /* nanotesla to Gauss */
1377 		.t_ref = 8120, /* counts */
1378 		.min_temp_x10 = -3860, /* 1/10:s degrees Celsius */
1379 		.get_measure = yas537_get_measure,
1380 		.get_calibration_data = yas537_get_calibration_data,
1381 		.dump_calibration = yas537_dump_calibration,
1382 		/* .measure_offets is not needed for yas537 */
1383 		.power_on = yas537_power_on,
1384 	},
1385 };
1386 
1387 static int yas5xx_probe(struct i2c_client *i2c,
1388 			const struct i2c_device_id *id)
1389 {
1390 	struct iio_dev *indio_dev;
1391 	struct device *dev = &i2c->dev;
1392 	struct yas5xx *yas5xx;
1393 	const struct yas5xx_chip_info *ci;
1394 	int id_check;
1395 	int ret;
1396 
1397 	indio_dev = devm_iio_device_alloc(dev, sizeof(*yas5xx));
1398 	if (!indio_dev)
1399 		return -ENOMEM;
1400 
1401 	yas5xx = iio_priv(indio_dev);
1402 	i2c_set_clientdata(i2c, indio_dev);
1403 	yas5xx->dev = dev;
1404 	mutex_init(&yas5xx->lock);
1405 
1406 	ret = iio_read_mount_matrix(dev, &yas5xx->orientation);
1407 	if (ret)
1408 		return ret;
1409 
1410 	yas5xx->regs[0].supply = "vdd";
1411 	yas5xx->regs[1].supply = "iovdd";
1412 	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(yas5xx->regs),
1413 				      yas5xx->regs);
1414 	if (ret)
1415 		return dev_err_probe(dev, ret, "cannot get regulators\n");
1416 
1417 	ret = regulator_bulk_enable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1418 	if (ret)
1419 		return dev_err_probe(dev, ret, "cannot enable regulators\n");
1420 
1421 	/* See comment in runtime resume callback */
1422 	usleep_range(31000, 40000);
1423 
1424 	/* This will take the device out of reset if need be */
1425 	yas5xx->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
1426 	if (IS_ERR(yas5xx->reset)) {
1427 		ret = dev_err_probe(dev, PTR_ERR(yas5xx->reset), "failed to get reset line\n");
1428 		goto reg_off;
1429 	}
1430 
1431 	yas5xx->map = devm_regmap_init_i2c(i2c, &yas5xx_regmap_config);
1432 	if (IS_ERR(yas5xx->map)) {
1433 		ret = dev_err_probe(dev, PTR_ERR(yas5xx->map), "failed to allocate register map\n");
1434 		goto assert_reset;
1435 	}
1436 
1437 	ci = device_get_match_data(dev);
1438 	if (!ci)
1439 		ci = (const struct yas5xx_chip_info *)id->driver_data;
1440 	yas5xx->chip_info = ci;
1441 
1442 	ret = regmap_read(yas5xx->map, YAS5XX_DEVICE_ID, &id_check);
1443 	if (ret)
1444 		goto assert_reset;
1445 
1446 	if (id_check != ci->devid) {
1447 		ret = dev_err_probe(dev, -ENODEV,
1448 				    "device ID %02x doesn't match %s\n",
1449 				    id_check, id->name);
1450 		goto assert_reset;
1451 	}
1452 
1453 	ret = ci->get_calibration_data(yas5xx);
1454 	if (ret)
1455 		goto assert_reset;
1456 
1457 	dev_info(dev, "detected %s %s\n", ci->product_name,
1458 		 ci->version_names[yas5xx->version]);
1459 
1460 	ci->dump_calibration(yas5xx);
1461 
1462 	ret = ci->power_on(yas5xx);
1463 	if (ret)
1464 		goto assert_reset;
1465 
1466 	if (ci->measure_offsets) {
1467 		ret = ci->measure_offsets(yas5xx);
1468 		if (ret)
1469 			goto assert_reset;
1470 	}
1471 
1472 	indio_dev->info = &yas5xx_info;
1473 	indio_dev->available_scan_masks = yas5xx_scan_masks;
1474 	indio_dev->modes = INDIO_DIRECT_MODE;
1475 	indio_dev->name = id->name;
1476 	indio_dev->channels = yas5xx_channels;
1477 	indio_dev->num_channels = ARRAY_SIZE(yas5xx_channels);
1478 
1479 	ret = iio_triggered_buffer_setup(indio_dev, NULL,
1480 					 yas5xx_handle_trigger,
1481 					 NULL);
1482 	if (ret) {
1483 		dev_err_probe(dev, ret, "triggered buffer setup failed\n");
1484 		goto assert_reset;
1485 	}
1486 
1487 	ret = iio_device_register(indio_dev);
1488 	if (ret) {
1489 		dev_err_probe(dev, ret, "device register failed\n");
1490 		goto cleanup_buffer;
1491 	}
1492 
1493 	/* Take runtime PM online */
1494 	pm_runtime_get_noresume(dev);
1495 	pm_runtime_set_active(dev);
1496 	pm_runtime_enable(dev);
1497 
1498 	pm_runtime_set_autosuspend_delay(dev, YAS5XX_AUTOSUSPEND_DELAY_MS);
1499 	pm_runtime_use_autosuspend(dev);
1500 	pm_runtime_put(dev);
1501 
1502 	return 0;
1503 
1504 cleanup_buffer:
1505 	iio_triggered_buffer_cleanup(indio_dev);
1506 assert_reset:
1507 	gpiod_set_value_cansleep(yas5xx->reset, 1);
1508 reg_off:
1509 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1510 
1511 	return ret;
1512 }
1513 
1514 static void yas5xx_remove(struct i2c_client *i2c)
1515 {
1516 	struct iio_dev *indio_dev = i2c_get_clientdata(i2c);
1517 	struct yas5xx *yas5xx = iio_priv(indio_dev);
1518 	struct device *dev = &i2c->dev;
1519 
1520 	iio_device_unregister(indio_dev);
1521 	iio_triggered_buffer_cleanup(indio_dev);
1522 	/*
1523 	 * Now we can't get any more reads from the device, which would
1524 	 * also call pm_runtime* functions and race with our disable
1525 	 * code. Disable PM runtime in orderly fashion and power down.
1526 	 */
1527 	pm_runtime_get_sync(dev);
1528 	pm_runtime_put_noidle(dev);
1529 	pm_runtime_disable(dev);
1530 	gpiod_set_value_cansleep(yas5xx->reset, 1);
1531 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1532 }
1533 
1534 static int yas5xx_runtime_suspend(struct device *dev)
1535 {
1536 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
1537 	struct yas5xx *yas5xx = iio_priv(indio_dev);
1538 
1539 	gpiod_set_value_cansleep(yas5xx->reset, 1);
1540 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1541 
1542 	return 0;
1543 }
1544 
1545 static int yas5xx_runtime_resume(struct device *dev)
1546 {
1547 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
1548 	struct yas5xx *yas5xx = iio_priv(indio_dev);
1549 	const struct yas5xx_chip_info *ci = yas5xx->chip_info;
1550 	int ret;
1551 
1552 	ret = regulator_bulk_enable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1553 	if (ret) {
1554 		dev_err(dev, "cannot enable regulators\n");
1555 		return ret;
1556 	}
1557 
1558 	/*
1559 	 * The YAS530 datasheet says TVSKW is up to 30 ms, after that 1 ms
1560 	 * for all voltages to settle. The YAS532 is 10ms then 4ms for the
1561 	 * I2C to come online. Let's keep it safe and put this at 31ms.
1562 	 */
1563 	usleep_range(31000, 40000);
1564 	gpiod_set_value_cansleep(yas5xx->reset, 0);
1565 
1566 	ret = ci->power_on(yas5xx);
1567 	if (ret) {
1568 		dev_err(dev, "cannot power on\n");
1569 		goto out_reset;
1570 	}
1571 
1572 	return 0;
1573 
1574 out_reset:
1575 	gpiod_set_value_cansleep(yas5xx->reset, 1);
1576 	regulator_bulk_disable(ARRAY_SIZE(yas5xx->regs), yas5xx->regs);
1577 
1578 	return ret;
1579 }
1580 
1581 static DEFINE_RUNTIME_DEV_PM_OPS(yas5xx_dev_pm_ops, yas5xx_runtime_suspend,
1582 				 yas5xx_runtime_resume, NULL);
1583 
1584 static const struct i2c_device_id yas5xx_id[] = {
1585 	{"yas530", (kernel_ulong_t)&yas5xx_chip_info_tbl[yas530] },
1586 	{"yas532", (kernel_ulong_t)&yas5xx_chip_info_tbl[yas532] },
1587 	{"yas533", (kernel_ulong_t)&yas5xx_chip_info_tbl[yas533] },
1588 	{"yas537", (kernel_ulong_t)&yas5xx_chip_info_tbl[yas537] },
1589 	{}
1590 };
1591 MODULE_DEVICE_TABLE(i2c, yas5xx_id);
1592 
1593 static const struct of_device_id yas5xx_of_match[] = {
1594 	{ .compatible = "yamaha,yas530", &yas5xx_chip_info_tbl[yas530] },
1595 	{ .compatible = "yamaha,yas532", &yas5xx_chip_info_tbl[yas532] },
1596 	{ .compatible = "yamaha,yas533", &yas5xx_chip_info_tbl[yas533] },
1597 	{ .compatible = "yamaha,yas537", &yas5xx_chip_info_tbl[yas537] },
1598 	{}
1599 };
1600 MODULE_DEVICE_TABLE(of, yas5xx_of_match);
1601 
1602 static struct i2c_driver yas5xx_driver = {
1603 	.driver	 = {
1604 		.name	= "yas5xx",
1605 		.of_match_table = yas5xx_of_match,
1606 		.pm = pm_ptr(&yas5xx_dev_pm_ops),
1607 	},
1608 	.probe	  = yas5xx_probe,
1609 	.remove	  = yas5xx_remove,
1610 	.id_table = yas5xx_id,
1611 };
1612 module_i2c_driver(yas5xx_driver);
1613 
1614 MODULE_DESCRIPTION("Yamaha YAS53x 3-axis magnetometer driver");
1615 MODULE_AUTHOR("Linus Walleij");
1616 MODULE_LICENSE("GPL v2");
1617