1 // SPDX-License-Identifier: GPL-2.0-only
3 * STMicroelectronics sensors core library driver
5 * Copyright 2012-2013 STMicroelectronics Inc.
7 * Denis Ciocca <denis.ciocca@st.com>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/delay.h>
14 #include <linux/iio/iio.h>
15 #include <linux/property.h>
16 #include <linux/regulator/consumer.h>
17 #include <linux/regmap.h>
18 #include <asm/unaligned.h>
19 #include <linux/iio/common/st_sensors.h>
21 #include "st_sensors_core.h"
23 static inline u32 st_sensors_get_unaligned_le24(const u8 *p)
25 return (s32)((p[0] | p[1] << 8 | p[2] << 16) << 8) >> 8;
28 int st_sensors_write_data_with_mask(struct iio_dev *indio_dev,
29 u8 reg_addr, u8 mask, u8 data)
31 struct st_sensor_data *sdata = iio_priv(indio_dev);
33 return regmap_update_bits(sdata->regmap,
34 reg_addr, mask, data << __ffs(mask));
37 int st_sensors_debugfs_reg_access(struct iio_dev *indio_dev,
38 unsigned reg, unsigned writeval,
41 struct st_sensor_data *sdata = iio_priv(indio_dev);
45 return regmap_write(sdata->regmap, reg, writeval);
47 err = regmap_read(sdata->regmap, reg, readval);
53 EXPORT_SYMBOL(st_sensors_debugfs_reg_access);
55 static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
56 unsigned int odr, struct st_sensor_odr_avl *odr_out)
60 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
61 if (sensor_settings->odr.odr_avl[i].hz == 0)
62 goto st_sensors_match_odr_error;
64 if (sensor_settings->odr.odr_avl[i].hz == odr) {
65 odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
66 odr_out->value = sensor_settings->odr.odr_avl[i].value;
72 st_sensors_match_odr_error:
76 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
79 struct st_sensor_odr_avl odr_out = {0, 0};
80 struct st_sensor_data *sdata = iio_priv(indio_dev);
82 if (!sdata->sensor_settings->odr.addr)
85 err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
87 goto st_sensors_match_odr_error;
89 if ((sdata->sensor_settings->odr.addr ==
90 sdata->sensor_settings->pw.addr) &&
91 (sdata->sensor_settings->odr.mask ==
92 sdata->sensor_settings->pw.mask)) {
93 if (sdata->enabled == true) {
94 err = st_sensors_write_data_with_mask(indio_dev,
95 sdata->sensor_settings->odr.addr,
96 sdata->sensor_settings->odr.mask,
102 err = st_sensors_write_data_with_mask(indio_dev,
103 sdata->sensor_settings->odr.addr,
104 sdata->sensor_settings->odr.mask,
108 sdata->odr = odr_out.hz;
110 st_sensors_match_odr_error:
113 EXPORT_SYMBOL(st_sensors_set_odr);
115 static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
116 unsigned int fs, int *index_fs_avl)
118 int i, ret = -EINVAL;
120 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
121 if (sensor_settings->fs.fs_avl[i].num == 0)
124 if (sensor_settings->fs.fs_avl[i].num == fs) {
134 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
137 struct st_sensor_data *sdata = iio_priv(indio_dev);
139 if (sdata->sensor_settings->fs.addr == 0)
142 err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
144 goto st_accel_set_fullscale_error;
146 err = st_sensors_write_data_with_mask(indio_dev,
147 sdata->sensor_settings->fs.addr,
148 sdata->sensor_settings->fs.mask,
149 sdata->sensor_settings->fs.fs_avl[i].value);
151 goto st_accel_set_fullscale_error;
153 sdata->current_fullscale = (struct st_sensor_fullscale_avl *)
154 &sdata->sensor_settings->fs.fs_avl[i];
157 st_accel_set_fullscale_error:
158 dev_err(&indio_dev->dev, "failed to set new fullscale.\n");
162 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
167 struct st_sensor_odr_avl odr_out = {0, 0};
168 struct st_sensor_data *sdata = iio_priv(indio_dev);
171 tmp_value = sdata->sensor_settings->pw.value_on;
172 if ((sdata->sensor_settings->odr.addr ==
173 sdata->sensor_settings->pw.addr) &&
174 (sdata->sensor_settings->odr.mask ==
175 sdata->sensor_settings->pw.mask)) {
176 err = st_sensors_match_odr(sdata->sensor_settings,
177 sdata->odr, &odr_out);
179 goto set_enable_error;
180 tmp_value = odr_out.value;
183 err = st_sensors_write_data_with_mask(indio_dev,
184 sdata->sensor_settings->pw.addr,
185 sdata->sensor_settings->pw.mask, tmp_value);
187 goto set_enable_error;
189 sdata->enabled = true;
192 sdata->odr = odr_out.hz;
194 err = st_sensors_write_data_with_mask(indio_dev,
195 sdata->sensor_settings->pw.addr,
196 sdata->sensor_settings->pw.mask,
197 sdata->sensor_settings->pw.value_off);
199 goto set_enable_error;
201 sdata->enabled = false;
207 EXPORT_SYMBOL(st_sensors_set_enable);
209 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
211 struct st_sensor_data *sdata = iio_priv(indio_dev);
214 if (sdata->sensor_settings->enable_axis.addr)
215 err = st_sensors_write_data_with_mask(indio_dev,
216 sdata->sensor_settings->enable_axis.addr,
217 sdata->sensor_settings->enable_axis.mask,
221 EXPORT_SYMBOL(st_sensors_set_axis_enable);
223 int st_sensors_power_enable(struct iio_dev *indio_dev)
225 struct st_sensor_data *pdata = iio_priv(indio_dev);
228 /* Regulators not mandatory, but if requested we should enable them. */
229 pdata->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
230 if (IS_ERR(pdata->vdd)) {
231 dev_err(&indio_dev->dev, "unable to get Vdd supply\n");
232 return PTR_ERR(pdata->vdd);
234 err = regulator_enable(pdata->vdd);
236 dev_warn(&indio_dev->dev,
237 "Failed to enable specified Vdd supply\n");
241 pdata->vdd_io = devm_regulator_get(indio_dev->dev.parent, "vddio");
242 if (IS_ERR(pdata->vdd_io)) {
243 dev_err(&indio_dev->dev, "unable to get Vdd_IO supply\n");
244 err = PTR_ERR(pdata->vdd_io);
245 goto st_sensors_disable_vdd;
247 err = regulator_enable(pdata->vdd_io);
249 dev_warn(&indio_dev->dev,
250 "Failed to enable specified Vdd_IO supply\n");
251 goto st_sensors_disable_vdd;
256 st_sensors_disable_vdd:
257 regulator_disable(pdata->vdd);
260 EXPORT_SYMBOL(st_sensors_power_enable);
262 void st_sensors_power_disable(struct iio_dev *indio_dev)
264 struct st_sensor_data *pdata = iio_priv(indio_dev);
266 regulator_disable(pdata->vdd);
267 regulator_disable(pdata->vdd_io);
269 EXPORT_SYMBOL(st_sensors_power_disable);
271 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
272 struct st_sensors_platform_data *pdata)
274 struct st_sensor_data *sdata = iio_priv(indio_dev);
276 /* Sensor does not support interrupts */
277 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
278 !sdata->sensor_settings->drdy_irq.int2.addr) {
279 if (pdata->drdy_int_pin)
280 dev_info(&indio_dev->dev,
281 "DRDY on pin INT%d specified, but sensor "
282 "does not support interrupts\n",
283 pdata->drdy_int_pin);
287 switch (pdata->drdy_int_pin) {
289 if (!sdata->sensor_settings->drdy_irq.int1.mask) {
290 dev_err(&indio_dev->dev,
291 "DRDY on INT1 not available.\n");
294 sdata->drdy_int_pin = 1;
297 if (!sdata->sensor_settings->drdy_irq.int2.mask) {
298 dev_err(&indio_dev->dev,
299 "DRDY on INT2 not available.\n");
302 sdata->drdy_int_pin = 2;
305 dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n");
309 if (pdata->open_drain) {
310 if (!sdata->sensor_settings->drdy_irq.int1.addr_od &&
311 !sdata->sensor_settings->drdy_irq.int2.addr_od)
312 dev_err(&indio_dev->dev,
313 "open drain requested but unsupported.\n");
315 sdata->int_pin_open_drain = true;
321 static struct st_sensors_platform_data *st_sensors_dev_probe(struct device *dev,
322 struct st_sensors_platform_data *defdata)
324 struct st_sensors_platform_data *pdata;
327 if (!dev_fwnode(dev))
330 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
332 return ERR_PTR(-ENOMEM);
333 if (!device_property_read_u32(dev, "st,drdy-int-pin", &val) && (val <= 2))
334 pdata->drdy_int_pin = (u8) val;
336 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
338 pdata->open_drain = device_property_read_bool(dev, "drive-open-drain");
344 * st_sensors_dev_name_probe() - device probe for ST sensor name
345 * @dev: driver model representation of the device.
346 * @name: device name buffer reference.
347 * @len: device name buffer length.
349 * In effect this function matches an ID to an internal kernel
350 * name for a certain sensor device, so that the rest of the autodetection can
351 * rely on that name from this point on. I2C/SPI devices will be renamed
352 * to match the internal kernel convention.
354 void st_sensors_dev_name_probe(struct device *dev, char *name, int len)
358 match = device_get_match_data(dev);
362 /* The name from the match takes precedence if present */
363 strlcpy(name, match, len);
365 EXPORT_SYMBOL(st_sensors_dev_name_probe);
367 int st_sensors_init_sensor(struct iio_dev *indio_dev,
368 struct st_sensors_platform_data *pdata)
370 struct st_sensor_data *sdata = iio_priv(indio_dev);
371 struct st_sensors_platform_data *of_pdata;
374 /* If OF/DT pdata exists, it will take precedence of anything else */
375 of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata);
376 if (IS_ERR(of_pdata))
377 return PTR_ERR(of_pdata);
382 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
387 err = st_sensors_set_enable(indio_dev, false);
391 /* Disable DRDY, this might be still be enabled after reboot. */
392 err = st_sensors_set_dataready_irq(indio_dev, false);
396 if (sdata->current_fullscale) {
397 err = st_sensors_set_fullscale(indio_dev,
398 sdata->current_fullscale->num);
402 dev_info(&indio_dev->dev, "Full-scale not possible\n");
404 err = st_sensors_set_odr(indio_dev, sdata->odr);
409 if (sdata->sensor_settings->bdu.addr) {
410 err = st_sensors_write_data_with_mask(indio_dev,
411 sdata->sensor_settings->bdu.addr,
412 sdata->sensor_settings->bdu.mask, true);
418 if (sdata->sensor_settings->das.addr) {
419 err = st_sensors_write_data_with_mask(indio_dev,
420 sdata->sensor_settings->das.addr,
421 sdata->sensor_settings->das.mask, 1);
426 if (sdata->int_pin_open_drain) {
429 if (sdata->drdy_int_pin == 1) {
430 addr = sdata->sensor_settings->drdy_irq.int1.addr_od;
431 mask = sdata->sensor_settings->drdy_irq.int1.mask_od;
433 addr = sdata->sensor_settings->drdy_irq.int2.addr_od;
434 mask = sdata->sensor_settings->drdy_irq.int2.mask_od;
437 dev_info(&indio_dev->dev,
438 "set interrupt line to open drain mode on pin %d\n",
439 sdata->drdy_int_pin);
440 err = st_sensors_write_data_with_mask(indio_dev, addr,
446 err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
450 EXPORT_SYMBOL(st_sensors_init_sensor);
452 int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
455 u8 drdy_addr, drdy_mask;
456 struct st_sensor_data *sdata = iio_priv(indio_dev);
458 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
459 !sdata->sensor_settings->drdy_irq.int2.addr) {
461 * there are some devices (e.g. LIS3MDL) where drdy line is
462 * routed to a given pin and it is not possible to select a
463 * different one. Take into account irq status register
464 * to understand if irq trigger can be properly supported
466 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr)
467 sdata->hw_irq_trigger = enable;
471 /* Enable/Disable the interrupt generator 1. */
472 if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
473 err = st_sensors_write_data_with_mask(indio_dev,
474 sdata->sensor_settings->drdy_irq.ig1.en_addr,
475 sdata->sensor_settings->drdy_irq.ig1.en_mask,
478 goto st_accel_set_dataready_irq_error;
481 if (sdata->drdy_int_pin == 1) {
482 drdy_addr = sdata->sensor_settings->drdy_irq.int1.addr;
483 drdy_mask = sdata->sensor_settings->drdy_irq.int1.mask;
485 drdy_addr = sdata->sensor_settings->drdy_irq.int2.addr;
486 drdy_mask = sdata->sensor_settings->drdy_irq.int2.mask;
489 /* Flag to the poll function that the hardware trigger is in use */
490 sdata->hw_irq_trigger = enable;
492 /* Enable/Disable the interrupt generator for data ready. */
493 err = st_sensors_write_data_with_mask(indio_dev, drdy_addr,
494 drdy_mask, (int)enable);
496 st_accel_set_dataready_irq_error:
499 EXPORT_SYMBOL(st_sensors_set_dataready_irq);
501 int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
503 int err = -EINVAL, i;
504 struct st_sensor_data *sdata = iio_priv(indio_dev);
506 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
507 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
508 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
514 goto st_sensors_match_scale_error;
516 err = st_sensors_set_fullscale(indio_dev,
517 sdata->sensor_settings->fs.fs_avl[i].num);
519 st_sensors_match_scale_error:
522 EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain);
524 static int st_sensors_read_axis_data(struct iio_dev *indio_dev,
525 struct iio_chan_spec const *ch, int *data)
529 struct st_sensor_data *sdata = iio_priv(indio_dev);
530 unsigned int byte_for_channel;
532 byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits +
533 ch->scan_type.shift, 8);
534 outdata = kmalloc(byte_for_channel, GFP_DMA | GFP_KERNEL);
538 err = regmap_bulk_read(sdata->regmap, ch->address,
539 outdata, byte_for_channel);
541 goto st_sensors_free_memory;
543 if (byte_for_channel == 1)
544 *data = (s8)*outdata;
545 else if (byte_for_channel == 2)
546 *data = (s16)get_unaligned_le16(outdata);
547 else if (byte_for_channel == 3)
548 *data = (s32)st_sensors_get_unaligned_le24(outdata);
550 st_sensors_free_memory:
556 int st_sensors_read_info_raw(struct iio_dev *indio_dev,
557 struct iio_chan_spec const *ch, int *val)
560 struct st_sensor_data *sdata = iio_priv(indio_dev);
562 mutex_lock(&indio_dev->mlock);
563 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
567 err = st_sensors_set_enable(indio_dev, true);
571 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
572 err = st_sensors_read_axis_data(indio_dev, ch, val);
576 *val = *val >> ch->scan_type.shift;
578 err = st_sensors_set_enable(indio_dev, false);
581 mutex_unlock(&indio_dev->mlock);
585 EXPORT_SYMBOL(st_sensors_read_info_raw);
588 * st_sensors_get_settings_index() - get index of the sensor settings for a
589 * specific device from list of settings
590 * @name: device name buffer reference.
591 * @list: sensor settings list.
592 * @list_length: length of sensor settings list.
594 * Return: non negative number on success (valid index),
595 * negative error code otherwise.
597 int st_sensors_get_settings_index(const char *name,
598 const struct st_sensor_settings *list,
599 const int list_length)
603 for (i = 0; i < list_length; i++) {
604 for (n = 0; n < ST_SENSORS_MAX_4WAI; n++) {
605 if (strcmp(name, list[i].sensors_supported[n]) == 0)
612 EXPORT_SYMBOL(st_sensors_get_settings_index);
615 * st_sensors_verify_id() - verify sensor ID (WhoAmI) is matching with the
617 * @indio_dev: IIO device reference.
619 * Return: 0 on success (valid sensor ID), else a negative error code.
621 int st_sensors_verify_id(struct iio_dev *indio_dev)
623 struct st_sensor_data *sdata = iio_priv(indio_dev);
626 if (sdata->sensor_settings->wai_addr) {
627 err = regmap_read(sdata->regmap,
628 sdata->sensor_settings->wai_addr, &wai);
630 dev_err(&indio_dev->dev,
631 "failed to read Who-Am-I register.\n");
635 if (sdata->sensor_settings->wai != wai) {
636 dev_err(&indio_dev->dev,
637 "%s: WhoAmI mismatch (0x%x).\n",
638 indio_dev->name, wai);
645 EXPORT_SYMBOL(st_sensors_verify_id);
647 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
648 struct device_attribute *attr, char *buf)
651 struct iio_dev *indio_dev = dev_get_drvdata(dev);
652 struct st_sensor_data *sdata = iio_priv(indio_dev);
654 mutex_lock(&indio_dev->mlock);
655 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
656 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
659 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
660 sdata->sensor_settings->odr.odr_avl[i].hz);
662 mutex_unlock(&indio_dev->mlock);
667 EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail);
669 ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
670 struct device_attribute *attr, char *buf)
672 int i, len = 0, q, r;
673 struct iio_dev *indio_dev = dev_get_drvdata(dev);
674 struct st_sensor_data *sdata = iio_priv(indio_dev);
676 mutex_lock(&indio_dev->mlock);
677 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
678 if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
681 q = sdata->sensor_settings->fs.fs_avl[i].gain / 1000000;
682 r = sdata->sensor_settings->fs.fs_avl[i].gain % 1000000;
684 len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", q, r);
686 mutex_unlock(&indio_dev->mlock);
691 EXPORT_SYMBOL(st_sensors_sysfs_scale_avail);
693 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
694 MODULE_DESCRIPTION("STMicroelectronics ST-sensors core");
695 MODULE_LICENSE("GPL v2");