kxsd9.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * kxsd9.c	simple support for the Kionix KXSD9 3D
  4 *		accelerometer.
  5 *
  6 * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org>
  7 *
  8 * The i2c interface is very similar, so shouldn't be a problem once
  9 * I have a suitable wire made up.
 10 *
 11 * TODO:	Support the motion detector
 12 */
 13
 14#include <linux/device.h>
 15#include <linux/kernel.h>
 16#include <linux/sysfs.h>
 17#include <linux/slab.h>
 18#include <linux/types.h>
 19#include <linux/module.h>
 20#include <linux/regmap.h>
 21#include <linux/bitops.h>
 22#include <linux/delay.h>
 23#include <linux/regulator/consumer.h>
 24#include <linux/pm_runtime.h>
 25#include <linux/iio/iio.h>
 26#include <linux/iio/sysfs.h>
 27#include <linux/iio/buffer.h>
 28#include <linux/iio/triggered_buffer.h>
 29#include <linux/iio/trigger_consumer.h>
 30
 31#include "kxsd9.h"
 32
 33#define KXSD9_REG_X		0x00
 34#define KXSD9_REG_Y		0x02
 35#define KXSD9_REG_Z		0x04
 36#define KXSD9_REG_AUX		0x06
 37#define KXSD9_REG_RESET		0x0a
 38#define KXSD9_REG_CTRL_C	0x0c
 39
 40#define KXSD9_CTRL_C_FS_MASK	0x03
 41#define KXSD9_CTRL_C_FS_8G	0x00
 42#define KXSD9_CTRL_C_FS_6G	0x01
 43#define KXSD9_CTRL_C_FS_4G	0x02
 44#define KXSD9_CTRL_C_FS_2G	0x03
 45#define KXSD9_CTRL_C_MOT_LAT	BIT(3)
 46#define KXSD9_CTRL_C_MOT_LEV	BIT(4)
 47#define KXSD9_CTRL_C_LP_MASK	0xe0
 48#define KXSD9_CTRL_C_LP_NONE	0x00
 49#define KXSD9_CTRL_C_LP_2000HZC	BIT(5)
 50#define KXSD9_CTRL_C_LP_2000HZB	BIT(6)
 51#define KXSD9_CTRL_C_LP_2000HZA	(BIT(5)|BIT(6))
 52#define KXSD9_CTRL_C_LP_1000HZ	BIT(7)
 53#define KXSD9_CTRL_C_LP_500HZ	(BIT(7)|BIT(5))
 54#define KXSD9_CTRL_C_LP_100HZ	(BIT(7)|BIT(6))
 55#define KXSD9_CTRL_C_LP_50HZ	(BIT(7)|BIT(6)|BIT(5))
 56
 57#define KXSD9_REG_CTRL_B	0x0d
 58
 59#define KXSD9_CTRL_B_CLK_HLD	BIT(7)
 60#define KXSD9_CTRL_B_ENABLE	BIT(6)
 61#define KXSD9_CTRL_B_ST		BIT(5) /* Self-test */
 62
 63#define KXSD9_REG_CTRL_A	0x0e
 64
 65/**
 66 * struct kxsd9_state - device related storage
 67 * @dev: pointer to the parent device
 68 * @map: regmap to the device
 69 * @orientation: mounting matrix, flipped axis etc
 70 * @regs: regulators for this device, VDD and IOVDD
 71 * @scale: the current scaling setting
 72 */
 73struct kxsd9_state {
 74	struct device *dev;
 75	struct regmap *map;
 76	struct iio_mount_matrix orientation;
 77	struct regulator_bulk_data regs[2];
 78	u8 scale;
 79};
 80
 81#define KXSD9_SCALE_2G "0.011978"
 82#define KXSD9_SCALE_4G "0.023927"
 83#define KXSD9_SCALE_6G "0.035934"
 84#define KXSD9_SCALE_8G "0.047853"
 85
 86/* reverse order */
 87static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };
 88
 89#define KXSD9_ZERO_G_OFFSET -2048
 90
 91/*
 92 * Regulator names
 93 */
 94static const char kxsd9_reg_vdd[] = "vdd";
 95static const char kxsd9_reg_iovdd[] = "iovdd";
 96
 97static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
 98{
 99	int ret, i;
100	struct kxsd9_state *st = iio_priv(indio_dev);
101	bool foundit = false;
102
103	for (i = 0; i < 4; i++)
104		if (micro == kxsd9_micro_scales[i]) {
105			foundit = true;
106			break;
107		}
108	if (!foundit)
109		return -EINVAL;
110
111	ret = regmap_update_bits(st->map,
112				 KXSD9_REG_CTRL_C,
113				 KXSD9_CTRL_C_FS_MASK,
114				 i);
115	if (ret < 0)
116		goto error_ret;
117
118	/* Cached scale when the sensor is powered down */
119	st->scale = i;
120
121error_ret:
122	return ret;
123}
124
125static IIO_CONST_ATTR(accel_scale_available,
126		KXSD9_SCALE_2G " "
127		KXSD9_SCALE_4G " "
128		KXSD9_SCALE_6G " "
129		KXSD9_SCALE_8G);
130
131static struct attribute *kxsd9_attributes[] = {
132	&iio_const_attr_accel_scale_available.dev_attr.attr,
133	NULL,
134};
135
136static int kxsd9_write_raw(struct iio_dev *indio_dev,
137			   struct iio_chan_spec const *chan,
138			   int val,
139			   int val2,
140			   long mask)
141{
142	int ret = -EINVAL;
143	struct kxsd9_state *st = iio_priv(indio_dev);
144
145	pm_runtime_get_sync(st->dev);
146
147	if (mask == IIO_CHAN_INFO_SCALE) {
148		/* Check no integer component */
149		if (val)
150			return -EINVAL;
151		ret = kxsd9_write_scale(indio_dev, val2);
152	}
153
154	pm_runtime_put_autosuspend(st->dev);
155
156	return ret;
157}
158
159static int kxsd9_read_raw(struct iio_dev *indio_dev,
160			  struct iio_chan_spec const *chan,
161			  int *val, int *val2, long mask)
162{
163	int ret = -EINVAL;
164	struct kxsd9_state *st = iio_priv(indio_dev);
165	unsigned int regval;
166	__be16 raw_val;
167	u16 nval;
168
169	pm_runtime_get_sync(st->dev);
170
171	switch (mask) {
172	case IIO_CHAN_INFO_RAW:
173		ret = regmap_bulk_read(st->map, chan->address, &raw_val,
174				       sizeof(raw_val));
175		if (ret)
176			goto error_ret;
177		nval = be16_to_cpu(raw_val);
178		/* Only 12 bits are valid */
179		nval >>= 4;
180		*val = nval;
181		ret = IIO_VAL_INT;
182		break;
183	case IIO_CHAN_INFO_OFFSET:
184		/* This has a bias of -2048 */
185		*val = KXSD9_ZERO_G_OFFSET;
186		ret = IIO_VAL_INT;
187		break;
188	case IIO_CHAN_INFO_SCALE:
189		ret = regmap_read(st->map,
190				  KXSD9_REG_CTRL_C,
191				  &regval);
192		if (ret < 0)
193			goto error_ret;
194		*val = 0;
195		*val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK];
196		ret = IIO_VAL_INT_PLUS_MICRO;
197		break;
198	}
199
200error_ret:
201	pm_runtime_put_autosuspend(st->dev);
202
203	return ret;
204};
205
206static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
207{
208	const struct iio_poll_func *pf = p;
209	struct iio_dev *indio_dev = pf->indio_dev;
210	struct kxsd9_state *st = iio_priv(indio_dev);
211	/*
212	 * Ensure correct positioning and alignment of timestamp.
213	 * No need to zero initialize as all elements written.
214	 */
215	struct {
216		__be16 chan[4];
217		aligned_s64 ts;
218	} hw_values;
219	int ret;
220
221	ret = regmap_bulk_read(st->map,
222			       KXSD9_REG_X,
223			       hw_values.chan,
224			       sizeof(hw_values.chan));
225	if (ret) {
226		dev_err(st->dev, "error reading data: %d\n", ret);
227		goto out;
228	}
229
230	iio_push_to_buffers_with_ts(indio_dev, &hw_values, sizeof(hw_values),
231				    iio_get_time_ns(indio_dev));
232out:
233	iio_trigger_notify_done(indio_dev->trig);
234
235	return IRQ_HANDLED;
236}
237
238static int kxsd9_buffer_preenable(struct iio_dev *indio_dev)
239{
240	struct kxsd9_state *st = iio_priv(indio_dev);
241
242	pm_runtime_get_sync(st->dev);
243
244	return 0;
245}
246
247static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev)
248{
249	struct kxsd9_state *st = iio_priv(indio_dev);
250
251	pm_runtime_put_autosuspend(st->dev);
252
253	return 0;
254}
255
256static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = {
257	.preenable = kxsd9_buffer_preenable,
258	.postdisable = kxsd9_buffer_postdisable,
259};
260
261static const struct iio_mount_matrix *
262kxsd9_get_mount_matrix(const struct iio_dev *indio_dev,
263		       const struct iio_chan_spec *chan)
264{
265	struct kxsd9_state *st = iio_priv(indio_dev);
266
267	return &st->orientation;
268}
269
270static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = {
271	IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix),
272	{ }
273};
274
275#define KXSD9_ACCEL_CHAN(axis, index)						\
276	{								\
277		.type = IIO_ACCEL,					\
278		.modified = 1,						\
279		.channel2 = IIO_MOD_##axis,				\
280		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
281		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |	\
282					BIT(IIO_CHAN_INFO_OFFSET),	\
283		.ext_info = kxsd9_ext_info,				\
284		.address = KXSD9_REG_##axis,				\
285		.scan_index = index,					\
286		.scan_type = {                                          \
287			.sign = 'u',					\
288			.realbits = 12,					\
289			.storagebits = 16,				\
290			.shift = 4,					\
291			.endianness = IIO_BE,				\
292		},							\
293	}
294
295static const struct iio_chan_spec kxsd9_channels[] = {
296	KXSD9_ACCEL_CHAN(X, 0),
297	KXSD9_ACCEL_CHAN(Y, 1),
298	KXSD9_ACCEL_CHAN(Z, 2),
299	{
300		.type = IIO_VOLTAGE,
301		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
302		.indexed = 1,
303		.address = KXSD9_REG_AUX,
304		.scan_index = 3,
305		.scan_type = {
306			.sign = 'u',
307			.realbits = 12,
308			.storagebits = 16,
309			.shift = 4,
310			.endianness = IIO_BE,
311		},
312	},
313	IIO_CHAN_SOFT_TIMESTAMP(4),
314};
315
316static const struct attribute_group kxsd9_attribute_group = {
317	.attrs = kxsd9_attributes,
318};
319
320static int kxsd9_power_up(struct kxsd9_state *st)
321{
322	int ret;
323
324	/* Enable the regulators */
325	ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs);
326	if (ret) {
327		dev_err(st->dev, "Cannot enable regulators\n");
328		return ret;
329	}
330
331	/* Power up */
332	ret = regmap_write(st->map,
333			   KXSD9_REG_CTRL_B,
334			   KXSD9_CTRL_B_ENABLE);
335	if (ret)
336		return ret;
337
338	/*
339	 * Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g,
340	 * latched wakeup
341	 */
342	ret = regmap_write(st->map,
343			   KXSD9_REG_CTRL_C,
344			   KXSD9_CTRL_C_LP_1000HZ |
345			   KXSD9_CTRL_C_MOT_LEV	|
346			   KXSD9_CTRL_C_MOT_LAT |
347			   st->scale);
348	if (ret)
349		return ret;
350
351	/*
352	 * Power-up time depends on the LPF setting, but typ 15.9 ms, let's
353	 * set 20 ms to allow for some slack.
354	 */
355	msleep(20);
356
357	return 0;
358};
359
360static int kxsd9_power_down(struct kxsd9_state *st)
361{
362	int ret;
363
364	/*
365	 * Set into low power mode - since there may be more users of the
366	 * regulators this is the first step of the power saving: it will
367	 * make sure we conserve power even if there are others users on the
368	 * regulators.
369	 */
370	ret = regmap_clear_bits(st->map, KXSD9_REG_CTRL_B, KXSD9_CTRL_B_ENABLE);
371	if (ret)
372		return ret;
373
374	/* Disable the regulators */
375	ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs);
376	if (ret) {
377		dev_err(st->dev, "Cannot disable regulators\n");
378		return ret;
379	}
380
381	return 0;
382}
383
384static const struct iio_info kxsd9_info = {
385	.read_raw = &kxsd9_read_raw,
386	.write_raw = &kxsd9_write_raw,
387	.attrs = &kxsd9_attribute_group,
388};
389
390/* Four channels apart from timestamp, scan mask = 0x0f */
391static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 };
392
393int kxsd9_common_probe(struct device *dev,
394		       struct regmap *map,
395		       const char *name)
396{
397	struct iio_dev *indio_dev;
398	struct kxsd9_state *st;
399	int ret;
400
401	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
402	if (!indio_dev)
403		return -ENOMEM;
404
405	st = iio_priv(indio_dev);
406	st->dev = dev;
407	st->map = map;
408
409	indio_dev->channels = kxsd9_channels;
410	indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
411	indio_dev->name = name;
412	indio_dev->info = &kxsd9_info;
413	indio_dev->modes = INDIO_DIRECT_MODE;
414	indio_dev->available_scan_masks = kxsd9_scan_masks;
415
416	/* Read the mounting matrix, if present */
417	ret = iio_read_mount_matrix(dev, &st->orientation);
418	if (ret)
419		return ret;
420
421	/* Fetch and turn on regulators */
422	st->regs[0].supply = kxsd9_reg_vdd;
423	st->regs[1].supply = kxsd9_reg_iovdd;
424	ret = devm_regulator_bulk_get(dev,
425				      ARRAY_SIZE(st->regs),
426				      st->regs);
427	if (ret) {
428		dev_err(dev, "Cannot get regulators\n");
429		return ret;
430	}
431	/* Default scaling */
432	st->scale = KXSD9_CTRL_C_FS_2G;
433
434	kxsd9_power_up(st);
435
436	ret = iio_triggered_buffer_setup(indio_dev,
437					 iio_pollfunc_store_time,
438					 kxsd9_trigger_handler,
439					 &kxsd9_buffer_setup_ops);
440	if (ret) {
441		dev_err(dev, "triggered buffer setup failed\n");
442		goto err_power_down;
443	}
444
445	ret = iio_device_register(indio_dev);
446	if (ret)
447		goto err_cleanup_buffer;
448
449	dev_set_drvdata(dev, indio_dev);
450
451	/* Enable runtime PM */
452	pm_runtime_get_noresume(dev);
453	pm_runtime_set_active(dev);
454	pm_runtime_enable(dev);
455	/*
456	 * Set autosuspend to two orders of magnitude larger than the
457	 * start-up time. 20ms start-up time means 2000ms autosuspend,
458	 * i.e. 2 seconds.
459	 */
460	pm_runtime_set_autosuspend_delay(dev, 2000);
461	pm_runtime_use_autosuspend(dev);
462	pm_runtime_put(dev);
463
464	return 0;
465
466err_cleanup_buffer:
467	iio_triggered_buffer_cleanup(indio_dev);
468err_power_down:
469	kxsd9_power_down(st);
470
471	return ret;
472}
473EXPORT_SYMBOL_NS(kxsd9_common_probe, "IIO_KXSD9");
474
475void kxsd9_common_remove(struct device *dev)
476{
477	struct iio_dev *indio_dev = dev_get_drvdata(dev);
478	struct kxsd9_state *st = iio_priv(indio_dev);
479
480	iio_triggered_buffer_cleanup(indio_dev);
481	iio_device_unregister(indio_dev);
482	pm_runtime_get_sync(dev);
483	pm_runtime_put_noidle(dev);
484	pm_runtime_disable(dev);
485	kxsd9_power_down(st);
486}
487EXPORT_SYMBOL_NS(kxsd9_common_remove, "IIO_KXSD9");
488
489static int kxsd9_runtime_suspend(struct device *dev)
490{
491	struct iio_dev *indio_dev = dev_get_drvdata(dev);
492	struct kxsd9_state *st = iio_priv(indio_dev);
493
494	return kxsd9_power_down(st);
495}
496
497static int kxsd9_runtime_resume(struct device *dev)
498{
499	struct iio_dev *indio_dev = dev_get_drvdata(dev);
500	struct kxsd9_state *st = iio_priv(indio_dev);
501
502	return kxsd9_power_up(st);
503}
504
505EXPORT_NS_RUNTIME_DEV_PM_OPS(kxsd9_dev_pm_ops, kxsd9_runtime_suspend,
506			     kxsd9_runtime_resume, NULL, IIO_KXSD9);
507
508MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
509MODULE_DESCRIPTION("Kionix KXSD9 driver");
510MODULE_LICENSE("GPL v2");