rm3100-core.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * PNI RM3100 3-axis geomagnetic sensor driver core.
  4 *
  5 * Copyright (C) 2018 Song Qiang <songqiang1304521@gmail.com>
  6 *
  7 * User Manual available at
  8 * <https://www.pnicorp.com/download/rm3100-user-manual/>
  9 *
 10 * TODO: event generation, pm.
 11 */
 12
 13#include <linux/delay.h>
 14#include <linux/interrupt.h>
 15#include <linux/module.h>
 16#include <linux/slab.h>
 17
 18#include <linux/iio/buffer.h>
 19#include <linux/iio/iio.h>
 20#include <linux/iio/sysfs.h>
 21#include <linux/iio/trigger.h>
 22#include <linux/iio/triggered_buffer.h>
 23#include <linux/iio/trigger_consumer.h>
 24
 25#include <linux/unaligned.h>
 26
 27#include "rm3100.h"
 28
 29/* Cycle Count Registers. */
 30#define RM3100_REG_CC_X			0x05
 31#define RM3100_REG_CC_Y			0x07
 32#define RM3100_REG_CC_Z			0x09
 33
 34/* Poll Measurement Mode register. */
 35#define RM3100_REG_POLL			0x00
 36#define		RM3100_POLL_X		BIT(4)
 37#define		RM3100_POLL_Y		BIT(5)
 38#define		RM3100_POLL_Z		BIT(6)
 39
 40/* Continuous Measurement Mode register. */
 41#define RM3100_REG_CMM			0x01
 42#define		RM3100_CMM_START	BIT(0)
 43#define		RM3100_CMM_X		BIT(4)
 44#define		RM3100_CMM_Y		BIT(5)
 45#define		RM3100_CMM_Z		BIT(6)
 46
 47/* TiMe Rate Configuration register. */
 48#define RM3100_REG_TMRC			0x0B
 49#define RM3100_TMRC_OFFSET		0x92
 50
 51/* Result Status register. */
 52#define RM3100_REG_STATUS		0x34
 53#define		RM3100_STATUS_DRDY	BIT(7)
 54
 55/* Measurement result registers. */
 56#define RM3100_REG_MX2			0x24
 57#define RM3100_REG_MY2			0x27
 58#define RM3100_REG_MZ2			0x2a
 59
 60#define RM3100_W_REG_START		RM3100_REG_POLL
 61#define RM3100_W_REG_END		RM3100_REG_TMRC
 62#define RM3100_R_REG_START		RM3100_REG_POLL
 63#define RM3100_R_REG_END		RM3100_REG_STATUS
 64#define RM3100_V_REG_START		RM3100_REG_POLL
 65#define RM3100_V_REG_END		RM3100_REG_STATUS
 66
 67/*
 68 * This is computed by hand, is the sum of channel storage bits and padding
 69 * bits, which is 4+4+4+12=24 in here.
 70 */
 71#define RM3100_SCAN_BYTES		24
 72
 73#define RM3100_CMM_AXIS_SHIFT		4
 74
 75struct rm3100_data {
 76	struct regmap *regmap;
 77	struct completion measuring_done;
 78	bool use_interrupt;
 79	int conversion_time;
 80	int scale;
 81	/* Ensure naturally aligned timestamp */
 82	u8 buffer[RM3100_SCAN_BYTES] __aligned(8);
 83	struct iio_trigger *drdy_trig;
 84
 85	/*
 86	 * This lock is for protecting the consistency of series of i2c
 87	 * operations, that is, to make sure a measurement process will
 88	 * not be interrupted by a set frequency operation, which should
 89	 * be taken where a series of i2c operation starts, released where
 90	 * the operation ends.
 91	 */
 92	struct mutex lock;
 93};
 94
 95static const struct regmap_range rm3100_readable_ranges[] = {
 96	regmap_reg_range(RM3100_R_REG_START, RM3100_R_REG_END),
 97};
 98
 99const struct regmap_access_table rm3100_readable_table = {
100	.yes_ranges = rm3100_readable_ranges,
101	.n_yes_ranges = ARRAY_SIZE(rm3100_readable_ranges),
102};
103EXPORT_SYMBOL_NS_GPL(rm3100_readable_table, "IIO_RM3100");
104
105static const struct regmap_range rm3100_writable_ranges[] = {
106	regmap_reg_range(RM3100_W_REG_START, RM3100_W_REG_END),
107};
108
109const struct regmap_access_table rm3100_writable_table = {
110	.yes_ranges = rm3100_writable_ranges,
111	.n_yes_ranges = ARRAY_SIZE(rm3100_writable_ranges),
112};
113EXPORT_SYMBOL_NS_GPL(rm3100_writable_table, "IIO_RM3100");
114
115static const struct regmap_range rm3100_volatile_ranges[] = {
116	regmap_reg_range(RM3100_V_REG_START, RM3100_V_REG_END),
117};
118
119const struct regmap_access_table rm3100_volatile_table = {
120	.yes_ranges = rm3100_volatile_ranges,
121	.n_yes_ranges = ARRAY_SIZE(rm3100_volatile_ranges),
122};
123EXPORT_SYMBOL_NS_GPL(rm3100_volatile_table, "IIO_RM3100");
124
125static irqreturn_t rm3100_thread_fn(int irq, void *d)
126{
127	struct iio_dev *indio_dev = d;
128	struct rm3100_data *data = iio_priv(indio_dev);
129
130	/*
131	 * Write operation to any register or read operation
132	 * to first byte of results will clear the interrupt.
133	 */
134	regmap_write(data->regmap, RM3100_REG_POLL, 0);
135
136	return IRQ_HANDLED;
137}
138
139static irqreturn_t rm3100_irq_handler(int irq, void *d)
140{
141	struct iio_dev *indio_dev = d;
142	struct rm3100_data *data = iio_priv(indio_dev);
143
144	if (!iio_buffer_enabled(indio_dev))
145		complete(&data->measuring_done);
146	else
147		iio_trigger_poll(data->drdy_trig);
148
149	return IRQ_WAKE_THREAD;
150}
151
152static int rm3100_wait_measurement(struct rm3100_data *data)
153{
154	struct regmap *regmap = data->regmap;
155	unsigned int val;
156	int tries = 20;
157	int ret;
158
159	/*
160	 * A read cycle of 400kbits i2c bus is about 20us, plus the time
161	 * used for scheduling, a read cycle of fast mode of this device
162	 * can reach 1.7ms, it may be possible for data to arrive just
163	 * after we check the RM3100_REG_STATUS. In this case, irq_handler is
164	 * called before measuring_done is reinitialized, it will wait
165	 * forever for data that has already been ready.
166	 * Reinitialize measuring_done before looking up makes sure we
167	 * will always capture interrupt no matter when it happens.
168	 */
169	if (data->use_interrupt)
170		reinit_completion(&data->measuring_done);
171
172	ret = regmap_read(regmap, RM3100_REG_STATUS, &val);
173	if (ret < 0)
174		return ret;
175
176	if ((val & RM3100_STATUS_DRDY) != RM3100_STATUS_DRDY) {
177		if (data->use_interrupt) {
178			ret = wait_for_completion_timeout(&data->measuring_done,
179				msecs_to_jiffies(data->conversion_time));
180			if (!ret)
181				return -ETIMEDOUT;
182		} else {
183			do {
184				usleep_range(1000, 5000);
185
186				ret = regmap_read(regmap, RM3100_REG_STATUS,
187						  &val);
188				if (ret < 0)
189					return ret;
190
191				if (val & RM3100_STATUS_DRDY)
192					break;
193			} while (--tries);
194			if (!tries)
195				return -ETIMEDOUT;
196		}
197	}
198	return 0;
199}
200
201static int rm3100_read_mag(struct rm3100_data *data, int idx, int *val)
202{
203	struct regmap *regmap = data->regmap;
204	u8 buffer[3];
205	int ret;
206
207	mutex_lock(&data->lock);
208	ret = regmap_write(regmap, RM3100_REG_POLL, BIT(4 + idx));
209	if (ret < 0)
210		goto unlock_return;
211
212	ret = rm3100_wait_measurement(data);
213	if (ret < 0)
214		goto unlock_return;
215
216	ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * idx, buffer, 3);
217	if (ret < 0)
218		goto unlock_return;
219	mutex_unlock(&data->lock);
220
221	*val = sign_extend32(get_unaligned_be24(&buffer[0]), 23);
222
223	return IIO_VAL_INT;
224
225unlock_return:
226	mutex_unlock(&data->lock);
227	return ret;
228}
229
230#define RM3100_CHANNEL(axis, idx)					\
231	{								\
232		.type = IIO_MAGN,					\
233		.modified = 1,						\
234		.channel2 = IIO_MOD_##axis,				\
235		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
236		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |	\
237			BIT(IIO_CHAN_INFO_SAMP_FREQ),			\
238		.scan_index = idx,					\
239		.scan_type = {						\
240			.sign = 's',					\
241			.realbits = 24,					\
242			.storagebits = 32,				\
243			.shift = 8,					\
244			.endianness = IIO_BE,				\
245		},							\
246	}
247
248static const struct iio_chan_spec rm3100_channels[] = {
249	RM3100_CHANNEL(X, 0),
250	RM3100_CHANNEL(Y, 1),
251	RM3100_CHANNEL(Z, 2),
252	IIO_CHAN_SOFT_TIMESTAMP(3),
253};
254
255static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
256	"600 300 150 75 37 18 9 4.5 2.3 1.2 0.6 0.3 0.015 0.075"
257);
258
259static struct attribute *rm3100_attributes[] = {
260	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
261	NULL,
262};
263
264static const struct attribute_group rm3100_attribute_group = {
265	.attrs = rm3100_attributes,
266};
267
268#define RM3100_SAMP_NUM			14
269
270/*
271 * Frequency : rm3100_samp_rates[][0].rm3100_samp_rates[][1]Hz.
272 * Time between reading: rm3100_sam_rates[][2]ms.
273 * The first one is actually 1.7ms.
274 */
275static const int rm3100_samp_rates[RM3100_SAMP_NUM][3] = {
276	{600, 0, 2}, {300, 0, 3}, {150, 0, 7}, {75, 0, 13}, {37, 0, 27},
277	{18, 0, 55}, {9, 0, 110}, {4, 500000, 220}, {2, 300000, 440},
278	{1, 200000, 800}, {0, 600000, 1600}, {0, 300000, 3300},
279	{0, 15000, 6700},  {0, 75000, 13000}
280};
281
282static int rm3100_get_samp_freq(struct rm3100_data *data, int *val, int *val2)
283{
284	unsigned int tmp;
285	int ret;
286
287	mutex_lock(&data->lock);
288	ret = regmap_read(data->regmap, RM3100_REG_TMRC, &tmp);
289	mutex_unlock(&data->lock);
290	if (ret < 0)
291		return ret;
292	*val = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][0];
293	*val2 = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][1];
294
295	return IIO_VAL_INT_PLUS_MICRO;
296}
297
298static int rm3100_set_cycle_count(struct rm3100_data *data, int val)
299{
300	int ret;
301	u8 i;
302
303	for (i = 0; i < 3; i++) {
304		ret = regmap_write(data->regmap, RM3100_REG_CC_X + 2 * i, val);
305		if (ret < 0)
306			return ret;
307	}
308
309	/*
310	 * The scale of this sensor depends on the cycle count value, these
311	 * three values are corresponding to the cycle count value 50, 100,
312	 * 200. scale = output / gain * 10^4.
313	 */
314	switch (val) {
315	case 50:
316		data->scale = 500;
317		break;
318	case 100:
319		data->scale = 263;
320		break;
321	/*
322	 * case 200:
323	 * This function will never be called by users' code, so here we
324	 * assume that it will never get a wrong parameter.
325	 */
326	default:
327		data->scale = 133;
328	}
329
330	return 0;
331}
332
333static int rm3100_set_samp_freq(struct iio_dev *indio_dev, int val, int val2)
334{
335	struct rm3100_data *data = iio_priv(indio_dev);
336	struct regmap *regmap = data->regmap;
337	unsigned int cycle_count;
338	int ret;
339	int i;
340
341	mutex_lock(&data->lock);
342	/* All cycle count registers use the same value. */
343	ret = regmap_read(regmap, RM3100_REG_CC_X, &cycle_count);
344	if (ret < 0)
345		goto unlock_return;
346
347	for (i = 0; i < RM3100_SAMP_NUM; i++) {
348		if (val == rm3100_samp_rates[i][0] &&
349		    val2 == rm3100_samp_rates[i][1])
350			break;
351	}
352	if (i == RM3100_SAMP_NUM) {
353		ret = -EINVAL;
354		goto unlock_return;
355	}
356
357	ret = regmap_write(regmap, RM3100_REG_TMRC, i + RM3100_TMRC_OFFSET);
358	if (ret < 0)
359		goto unlock_return;
360
361	/* Checking if cycle count registers need changing. */
362	if (val == 600 && cycle_count == 200) {
363		ret = rm3100_set_cycle_count(data, 100);
364		if (ret < 0)
365			goto unlock_return;
366	} else if (val != 600 && cycle_count == 100) {
367		ret = rm3100_set_cycle_count(data, 200);
368		if (ret < 0)
369			goto unlock_return;
370	}
371
372	if (iio_buffer_enabled(indio_dev)) {
373		/* Writing TMRC registers requires CMM reset. */
374		ret = regmap_write(regmap, RM3100_REG_CMM, 0);
375		if (ret < 0)
376			goto unlock_return;
377		ret = regmap_write(data->regmap, RM3100_REG_CMM,
378			(*indio_dev->active_scan_mask & 0x7) <<
379			RM3100_CMM_AXIS_SHIFT | RM3100_CMM_START);
380		if (ret < 0)
381			goto unlock_return;
382	}
383	mutex_unlock(&data->lock);
384
385	data->conversion_time = rm3100_samp_rates[i][2] * 2;
386	return 0;
387
388unlock_return:
389	mutex_unlock(&data->lock);
390	return ret;
391}
392
393static int rm3100_read_raw(struct iio_dev *indio_dev,
394			   const struct iio_chan_spec *chan,
395			   int *val, int *val2, long mask)
396{
397	struct rm3100_data *data = iio_priv(indio_dev);
398	int ret;
399
400	switch (mask) {
401	case IIO_CHAN_INFO_RAW:
402		if (!iio_device_claim_direct(indio_dev))
403			return -EBUSY;
404
405		ret = rm3100_read_mag(data, chan->scan_index, val);
406		iio_device_release_direct(indio_dev);
407
408		return ret;
409	case IIO_CHAN_INFO_SCALE:
410		*val = 0;
411		*val2 = data->scale;
412
413		return IIO_VAL_INT_PLUS_MICRO;
414	case IIO_CHAN_INFO_SAMP_FREQ:
415		return rm3100_get_samp_freq(data, val, val2);
416	default:
417		return -EINVAL;
418	}
419}
420
421static int rm3100_write_raw(struct iio_dev *indio_dev,
422			    struct iio_chan_spec const *chan,
423			    int val, int val2, long mask)
424{
425	switch (mask) {
426	case IIO_CHAN_INFO_SAMP_FREQ:
427		return rm3100_set_samp_freq(indio_dev, val, val2);
428	default:
429		return -EINVAL;
430	}
431}
432
433static const struct iio_info rm3100_info = {
434	.attrs = &rm3100_attribute_group,
435	.read_raw = rm3100_read_raw,
436	.write_raw = rm3100_write_raw,
437};
438
439static int rm3100_buffer_preenable(struct iio_dev *indio_dev)
440{
441	struct rm3100_data *data = iio_priv(indio_dev);
442
443	/* Starting channels enabled. */
444	return regmap_write(data->regmap, RM3100_REG_CMM,
445		(*indio_dev->active_scan_mask & 0x7) << RM3100_CMM_AXIS_SHIFT |
446		RM3100_CMM_START);
447}
448
449static int rm3100_buffer_postdisable(struct iio_dev *indio_dev)
450{
451	struct rm3100_data *data = iio_priv(indio_dev);
452
453	return regmap_write(data->regmap, RM3100_REG_CMM, 0);
454}
455
456static const struct iio_buffer_setup_ops rm3100_buffer_ops = {
457	.preenable = rm3100_buffer_preenable,
458	.postdisable = rm3100_buffer_postdisable,
459};
460
461static irqreturn_t rm3100_trigger_handler(int irq, void *p)
462{
463	struct iio_poll_func *pf = p;
464	struct iio_dev *indio_dev = pf->indio_dev;
465	unsigned long scan_mask = *indio_dev->active_scan_mask;
466	unsigned int mask_len = iio_get_masklength(indio_dev);
467	struct rm3100_data *data = iio_priv(indio_dev);
468	struct regmap *regmap = data->regmap;
469	int ret, i, bit;
470
471	mutex_lock(&data->lock);
472	switch (scan_mask) {
473	case BIT(0) | BIT(1) | BIT(2):
474		ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9);
475		mutex_unlock(&data->lock);
476		if (ret < 0)
477			goto done;
478		/* Convert XXXYYYZZZxxx to XXXxYYYxZZZx. x for paddings. */
479		for (i = 2; i > 0; i--)
480			memmove(data->buffer + i * 4, data->buffer + i * 3, 3);
481		break;
482	case BIT(0) | BIT(1):
483		ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 6);
484		mutex_unlock(&data->lock);
485		if (ret < 0)
486			goto done;
487		memmove(data->buffer + 4, data->buffer + 3, 3);
488		break;
489	case BIT(1) | BIT(2):
490		ret = regmap_bulk_read(regmap, RM3100_REG_MY2, data->buffer, 6);
491		mutex_unlock(&data->lock);
492		if (ret < 0)
493			goto done;
494		memmove(data->buffer + 4, data->buffer + 3, 3);
495		break;
496	case BIT(0) | BIT(2):
497		ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9);
498		mutex_unlock(&data->lock);
499		if (ret < 0)
500			goto done;
501		memmove(data->buffer + 4, data->buffer + 6, 3);
502		break;
503	default:
504		for_each_set_bit(bit, &scan_mask, mask_len) {
505			ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * bit,
506					       data->buffer, 3);
507			if (ret < 0) {
508				mutex_unlock(&data->lock);
509				goto done;
510			}
511		}
512		mutex_unlock(&data->lock);
513	}
514	/*
515	 * Always using the same buffer so that we wouldn't need to set the
516	 * paddings to 0 in case of leaking any data.
517	 */
518	iio_push_to_buffers_with_ts(indio_dev, data->buffer, sizeof(data->buffer),
519				    pf->timestamp);
520done:
521	iio_trigger_notify_done(indio_dev->trig);
522
523	return IRQ_HANDLED;
524}
525
526int rm3100_common_probe(struct device *dev, struct regmap *regmap, int irq)
527{
528	struct iio_dev *indio_dev;
529	struct rm3100_data *data;
530	unsigned int tmp;
531	int ret;
532	int samp_rate_index;
533
534	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
535	if (!indio_dev)
536		return -ENOMEM;
537
538	data = iio_priv(indio_dev);
539	data->regmap = regmap;
540
541	mutex_init(&data->lock);
542
543	indio_dev->name = "rm3100";
544	indio_dev->info = &rm3100_info;
545	indio_dev->channels = rm3100_channels;
546	indio_dev->num_channels = ARRAY_SIZE(rm3100_channels);
547	indio_dev->modes = INDIO_DIRECT_MODE;
548
549	if (!irq)
550		data->use_interrupt = false;
551	else {
552		data->use_interrupt = true;
553
554		init_completion(&data->measuring_done);
555		ret = devm_request_threaded_irq(dev,
556						irq,
557						rm3100_irq_handler,
558						rm3100_thread_fn,
559						IRQF_TRIGGER_HIGH |
560						IRQF_ONESHOT,
561						indio_dev->name,
562						indio_dev);
563		if (ret < 0) {
564			dev_err(dev, "request irq line failed.\n");
565			return ret;
566		}
567
568		data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-drdy%d",
569							 indio_dev->name,
570							 iio_device_id(indio_dev));
571		if (!data->drdy_trig)
572			return -ENOMEM;
573
574		ret = devm_iio_trigger_register(dev, data->drdy_trig);
575		if (ret < 0)
576			return ret;
577	}
578
579	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
580					      &iio_pollfunc_store_time,
581					      rm3100_trigger_handler,
582					      &rm3100_buffer_ops);
583	if (ret < 0)
584		return ret;
585
586	ret = regmap_read(regmap, RM3100_REG_TMRC, &tmp);
587	if (ret < 0)
588		return ret;
589
590	samp_rate_index = tmp - RM3100_TMRC_OFFSET;
591	if (samp_rate_index < 0 || samp_rate_index >=  RM3100_SAMP_NUM) {
592		dev_err(dev, "The value read from RM3100_REG_TMRC is invalid!\n");
593		return -EINVAL;
594	}
595	/* Initializing max wait time, which is double conversion time. */
596	data->conversion_time = rm3100_samp_rates[samp_rate_index][2] * 2;
597
598	/* Cycle count values may not be what we want. */
599	if ((tmp - RM3100_TMRC_OFFSET) == 0)
600		rm3100_set_cycle_count(data, 100);
601	else
602		rm3100_set_cycle_count(data, 200);
603
604	return devm_iio_device_register(dev, indio_dev);
605}
606EXPORT_SYMBOL_NS_GPL(rm3100_common_probe, "IIO_RM3100");
607
608MODULE_AUTHOR("Song Qiang <songqiang1304521@gmail.com>");
609MODULE_DESCRIPTION("PNI RM3100 3-axis magnetometer i2c driver");
610MODULE_LICENSE("GPL v2");