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