Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 ®val);
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");