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/mutex.h>
16 #include <linux/property.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/regmap.h>
19 #include <asm/unaligned.h>
20 #include <linux/iio/common/st_sensors.h>
22 #include "st_sensors_core.h"
24 int st_sensors_write_data_with_mask(struct iio_dev *indio_dev,
25 u8 reg_addr, u8 mask, u8 data)
27 struct st_sensor_data *sdata = iio_priv(indio_dev);
29 return regmap_update_bits(sdata->regmap,
30 reg_addr, mask, data << __ffs(mask));
33 int st_sensors_debugfs_reg_access(struct iio_dev *indio_dev,
34 unsigned reg, unsigned writeval,
37 struct st_sensor_data *sdata = iio_priv(indio_dev);
41 return regmap_write(sdata->regmap, reg, writeval);
43 err = regmap_read(sdata->regmap, reg, readval);
49 EXPORT_SYMBOL(st_sensors_debugfs_reg_access);
51 static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
52 unsigned int odr, struct st_sensor_odr_avl *odr_out)
56 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
57 if (sensor_settings->odr.odr_avl[i].hz == 0)
58 goto st_sensors_match_odr_error;
60 if (sensor_settings->odr.odr_avl[i].hz == odr) {
61 odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
62 odr_out->value = sensor_settings->odr.odr_avl[i].value;
68 st_sensors_match_odr_error:
72 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
75 struct st_sensor_odr_avl odr_out = {0, 0};
76 struct st_sensor_data *sdata = iio_priv(indio_dev);
78 if (!sdata->sensor_settings->odr.mask)
81 err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
83 goto st_sensors_match_odr_error;
85 if ((sdata->sensor_settings->odr.addr ==
86 sdata->sensor_settings->pw.addr) &&
87 (sdata->sensor_settings->odr.mask ==
88 sdata->sensor_settings->pw.mask)) {
89 if (sdata->enabled == true) {
90 err = st_sensors_write_data_with_mask(indio_dev,
91 sdata->sensor_settings->odr.addr,
92 sdata->sensor_settings->odr.mask,
98 err = st_sensors_write_data_with_mask(indio_dev,
99 sdata->sensor_settings->odr.addr,
100 sdata->sensor_settings->odr.mask,
104 sdata->odr = odr_out.hz;
106 st_sensors_match_odr_error:
109 EXPORT_SYMBOL(st_sensors_set_odr);
111 static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
112 unsigned int fs, int *index_fs_avl)
114 int i, ret = -EINVAL;
116 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
117 if (sensor_settings->fs.fs_avl[i].num == 0)
120 if (sensor_settings->fs.fs_avl[i].num == fs) {
130 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
133 struct st_sensor_data *sdata = iio_priv(indio_dev);
135 if (sdata->sensor_settings->fs.addr == 0)
138 err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
140 goto st_accel_set_fullscale_error;
142 err = st_sensors_write_data_with_mask(indio_dev,
143 sdata->sensor_settings->fs.addr,
144 sdata->sensor_settings->fs.mask,
145 sdata->sensor_settings->fs.fs_avl[i].value);
147 goto st_accel_set_fullscale_error;
149 sdata->current_fullscale = &sdata->sensor_settings->fs.fs_avl[i];
152 st_accel_set_fullscale_error:
153 dev_err(&indio_dev->dev, "failed to set new fullscale.\n");
157 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
162 struct st_sensor_odr_avl odr_out = {0, 0};
163 struct st_sensor_data *sdata = iio_priv(indio_dev);
166 tmp_value = sdata->sensor_settings->pw.value_on;
167 if ((sdata->sensor_settings->odr.addr ==
168 sdata->sensor_settings->pw.addr) &&
169 (sdata->sensor_settings->odr.mask ==
170 sdata->sensor_settings->pw.mask)) {
171 err = st_sensors_match_odr(sdata->sensor_settings,
172 sdata->odr, &odr_out);
174 goto set_enable_error;
175 tmp_value = odr_out.value;
178 err = st_sensors_write_data_with_mask(indio_dev,
179 sdata->sensor_settings->pw.addr,
180 sdata->sensor_settings->pw.mask, tmp_value);
182 goto set_enable_error;
184 sdata->enabled = true;
187 sdata->odr = odr_out.hz;
189 err = st_sensors_write_data_with_mask(indio_dev,
190 sdata->sensor_settings->pw.addr,
191 sdata->sensor_settings->pw.mask,
192 sdata->sensor_settings->pw.value_off);
194 goto set_enable_error;
196 sdata->enabled = false;
202 EXPORT_SYMBOL(st_sensors_set_enable);
204 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
206 struct st_sensor_data *sdata = iio_priv(indio_dev);
209 if (sdata->sensor_settings->enable_axis.addr)
210 err = st_sensors_write_data_with_mask(indio_dev,
211 sdata->sensor_settings->enable_axis.addr,
212 sdata->sensor_settings->enable_axis.mask,
216 EXPORT_SYMBOL(st_sensors_set_axis_enable);
218 static void st_reg_disable(void *reg)
220 regulator_disable(reg);
223 int st_sensors_power_enable(struct iio_dev *indio_dev)
225 struct st_sensor_data *pdata = iio_priv(indio_dev);
226 struct device *parent = indio_dev->dev.parent;
229 /* Regulators not mandatory, but if requested we should enable them. */
230 pdata->vdd = devm_regulator_get(parent, "vdd");
231 if (IS_ERR(pdata->vdd))
232 return dev_err_probe(&indio_dev->dev, PTR_ERR(pdata->vdd),
233 "unable to get Vdd supply\n");
235 err = regulator_enable(pdata->vdd);
237 dev_warn(&indio_dev->dev,
238 "Failed to enable specified Vdd supply\n");
242 err = devm_add_action_or_reset(parent, st_reg_disable, pdata->vdd);
246 pdata->vdd_io = devm_regulator_get(parent, "vddio");
247 if (IS_ERR(pdata->vdd_io))
248 return dev_err_probe(&indio_dev->dev, PTR_ERR(pdata->vdd_io),
249 "unable to get Vdd_IO supply\n");
251 err = regulator_enable(pdata->vdd_io);
253 dev_warn(&indio_dev->dev,
254 "Failed to enable specified Vdd_IO supply\n");
258 return devm_add_action_or_reset(parent, st_reg_disable, pdata->vdd_io);
260 EXPORT_SYMBOL(st_sensors_power_enable);
262 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
263 struct st_sensors_platform_data *pdata)
265 struct st_sensor_data *sdata = iio_priv(indio_dev);
267 /* Sensor does not support interrupts */
268 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
269 !sdata->sensor_settings->drdy_irq.int2.addr) {
270 if (pdata->drdy_int_pin)
271 dev_info(&indio_dev->dev,
272 "DRDY on pin INT%d specified, but sensor does not support interrupts\n",
273 pdata->drdy_int_pin);
277 switch (pdata->drdy_int_pin) {
279 if (!sdata->sensor_settings->drdy_irq.int1.mask) {
280 dev_err(&indio_dev->dev,
281 "DRDY on INT1 not available.\n");
284 sdata->drdy_int_pin = 1;
287 if (!sdata->sensor_settings->drdy_irq.int2.mask) {
288 dev_err(&indio_dev->dev,
289 "DRDY on INT2 not available.\n");
292 sdata->drdy_int_pin = 2;
295 dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n");
299 if (pdata->open_drain) {
300 if (!sdata->sensor_settings->drdy_irq.int1.addr_od &&
301 !sdata->sensor_settings->drdy_irq.int2.addr_od)
302 dev_err(&indio_dev->dev,
303 "open drain requested but unsupported.\n");
305 sdata->int_pin_open_drain = true;
311 static struct st_sensors_platform_data *st_sensors_dev_probe(struct device *dev,
312 struct st_sensors_platform_data *defdata)
314 struct st_sensors_platform_data *pdata;
317 if (!dev_fwnode(dev))
320 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
322 return ERR_PTR(-ENOMEM);
323 if (!device_property_read_u32(dev, "st,drdy-int-pin", &val) && (val <= 2))
324 pdata->drdy_int_pin = (u8) val;
326 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
328 pdata->open_drain = device_property_read_bool(dev, "drive-open-drain");
334 * st_sensors_dev_name_probe() - device probe for ST sensor name
335 * @dev: driver model representation of the device.
336 * @name: device name buffer reference.
337 * @len: device name buffer length.
339 * In effect this function matches an ID to an internal kernel
340 * name for a certain sensor device, so that the rest of the autodetection can
341 * rely on that name from this point on. I2C/SPI devices will be renamed
342 * to match the internal kernel convention.
344 void st_sensors_dev_name_probe(struct device *dev, char *name, int len)
348 match = device_get_match_data(dev);
352 /* The name from the match takes precedence if present */
353 strlcpy(name, match, len);
355 EXPORT_SYMBOL(st_sensors_dev_name_probe);
357 int st_sensors_init_sensor(struct iio_dev *indio_dev,
358 struct st_sensors_platform_data *pdata)
360 struct st_sensor_data *sdata = iio_priv(indio_dev);
361 struct st_sensors_platform_data *of_pdata;
364 /* If OF/DT pdata exists, it will take precedence of anything else */
365 of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata);
366 if (IS_ERR(of_pdata))
367 return PTR_ERR(of_pdata);
372 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
377 err = st_sensors_set_enable(indio_dev, false);
381 /* Disable DRDY, this might be still be enabled after reboot. */
382 err = st_sensors_set_dataready_irq(indio_dev, false);
386 if (sdata->current_fullscale) {
387 err = st_sensors_set_fullscale(indio_dev,
388 sdata->current_fullscale->num);
392 dev_info(&indio_dev->dev, "Full-scale not possible\n");
394 err = st_sensors_set_odr(indio_dev, sdata->odr);
399 if (sdata->sensor_settings->bdu.addr) {
400 err = st_sensors_write_data_with_mask(indio_dev,
401 sdata->sensor_settings->bdu.addr,
402 sdata->sensor_settings->bdu.mask, true);
408 if (sdata->sensor_settings->das.addr) {
409 err = st_sensors_write_data_with_mask(indio_dev,
410 sdata->sensor_settings->das.addr,
411 sdata->sensor_settings->das.mask, 1);
416 if (sdata->int_pin_open_drain) {
419 if (sdata->drdy_int_pin == 1) {
420 addr = sdata->sensor_settings->drdy_irq.int1.addr_od;
421 mask = sdata->sensor_settings->drdy_irq.int1.mask_od;
423 addr = sdata->sensor_settings->drdy_irq.int2.addr_od;
424 mask = sdata->sensor_settings->drdy_irq.int2.mask_od;
427 dev_info(&indio_dev->dev,
428 "set interrupt line to open drain mode on pin %d\n",
429 sdata->drdy_int_pin);
430 err = st_sensors_write_data_with_mask(indio_dev, addr,
436 err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
440 EXPORT_SYMBOL(st_sensors_init_sensor);
442 int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
445 u8 drdy_addr, drdy_mask;
446 struct st_sensor_data *sdata = iio_priv(indio_dev);
448 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
449 !sdata->sensor_settings->drdy_irq.int2.addr) {
451 * there are some devices (e.g. LIS3MDL) where drdy line is
452 * routed to a given pin and it is not possible to select a
453 * different one. Take into account irq status register
454 * to understand if irq trigger can be properly supported
456 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr)
457 sdata->hw_irq_trigger = enable;
461 /* Enable/Disable the interrupt generator 1. */
462 if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
463 err = st_sensors_write_data_with_mask(indio_dev,
464 sdata->sensor_settings->drdy_irq.ig1.en_addr,
465 sdata->sensor_settings->drdy_irq.ig1.en_mask,
468 goto st_accel_set_dataready_irq_error;
471 if (sdata->drdy_int_pin == 1) {
472 drdy_addr = sdata->sensor_settings->drdy_irq.int1.addr;
473 drdy_mask = sdata->sensor_settings->drdy_irq.int1.mask;
475 drdy_addr = sdata->sensor_settings->drdy_irq.int2.addr;
476 drdy_mask = sdata->sensor_settings->drdy_irq.int2.mask;
479 /* Flag to the poll function that the hardware trigger is in use */
480 sdata->hw_irq_trigger = enable;
482 /* Enable/Disable the interrupt generator for data ready. */
483 err = st_sensors_write_data_with_mask(indio_dev, drdy_addr,
484 drdy_mask, (int)enable);
486 st_accel_set_dataready_irq_error:
489 EXPORT_SYMBOL(st_sensors_set_dataready_irq);
491 int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
493 int err = -EINVAL, i;
494 struct st_sensor_data *sdata = iio_priv(indio_dev);
496 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
497 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
498 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
504 goto st_sensors_match_scale_error;
506 err = st_sensors_set_fullscale(indio_dev,
507 sdata->sensor_settings->fs.fs_avl[i].num);
509 st_sensors_match_scale_error:
512 EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain);
514 static int st_sensors_read_axis_data(struct iio_dev *indio_dev,
515 struct iio_chan_spec const *ch, int *data)
519 struct st_sensor_data *sdata = iio_priv(indio_dev);
520 unsigned int byte_for_channel;
522 byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits +
523 ch->scan_type.shift, 8);
524 outdata = kmalloc(byte_for_channel, GFP_DMA | GFP_KERNEL);
528 err = regmap_bulk_read(sdata->regmap, ch->address,
529 outdata, byte_for_channel);
531 goto st_sensors_free_memory;
533 if (byte_for_channel == 1)
534 *data = (s8)*outdata;
535 else if (byte_for_channel == 2)
536 *data = (s16)get_unaligned_le16(outdata);
537 else if (byte_for_channel == 3)
538 *data = (s32)sign_extend32(get_unaligned_le24(outdata), 23);
540 st_sensors_free_memory:
546 int st_sensors_read_info_raw(struct iio_dev *indio_dev,
547 struct iio_chan_spec const *ch, int *val)
550 struct st_sensor_data *sdata = iio_priv(indio_dev);
552 mutex_lock(&indio_dev->mlock);
553 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
557 err = st_sensors_set_enable(indio_dev, true);
561 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
562 err = st_sensors_read_axis_data(indio_dev, ch, val);
566 *val = *val >> ch->scan_type.shift;
568 err = st_sensors_set_enable(indio_dev, false);
571 mutex_unlock(&indio_dev->mlock);
575 EXPORT_SYMBOL(st_sensors_read_info_raw);
578 * st_sensors_get_settings_index() - get index of the sensor settings for a
579 * specific device from list of settings
580 * @name: device name buffer reference.
581 * @list: sensor settings list.
582 * @list_length: length of sensor settings list.
584 * Return: non negative number on success (valid index),
585 * negative error code otherwise.
587 int st_sensors_get_settings_index(const char *name,
588 const struct st_sensor_settings *list,
589 const int list_length)
593 for (i = 0; i < list_length; i++) {
594 for (n = 0; n < ST_SENSORS_MAX_4WAI; n++) {
595 if (strcmp(name, list[i].sensors_supported[n]) == 0)
602 EXPORT_SYMBOL(st_sensors_get_settings_index);
605 * st_sensors_verify_id() - verify sensor ID (WhoAmI) is matching with the
607 * @indio_dev: IIO device reference.
609 * Return: 0 on success (valid sensor ID), else a negative error code.
611 int st_sensors_verify_id(struct iio_dev *indio_dev)
613 struct st_sensor_data *sdata = iio_priv(indio_dev);
616 if (sdata->sensor_settings->wai_addr) {
617 err = regmap_read(sdata->regmap,
618 sdata->sensor_settings->wai_addr, &wai);
620 dev_err(&indio_dev->dev,
621 "failed to read Who-Am-I register.\n");
625 if (sdata->sensor_settings->wai != wai) {
626 dev_err(&indio_dev->dev,
627 "%s: WhoAmI mismatch (0x%x).\n",
628 indio_dev->name, wai);
635 EXPORT_SYMBOL(st_sensors_verify_id);
637 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
638 struct device_attribute *attr, char *buf)
641 struct iio_dev *indio_dev = dev_get_drvdata(dev);
642 struct st_sensor_data *sdata = iio_priv(indio_dev);
644 mutex_lock(&indio_dev->mlock);
645 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
646 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
649 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
650 sdata->sensor_settings->odr.odr_avl[i].hz);
652 mutex_unlock(&indio_dev->mlock);
657 EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail);
659 ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
660 struct device_attribute *attr, char *buf)
662 int i, len = 0, q, r;
663 struct iio_dev *indio_dev = dev_get_drvdata(dev);
664 struct st_sensor_data *sdata = iio_priv(indio_dev);
666 mutex_lock(&indio_dev->mlock);
667 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
668 if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
671 q = sdata->sensor_settings->fs.fs_avl[i].gain / 1000000;
672 r = sdata->sensor_settings->fs.fs_avl[i].gain % 1000000;
674 len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", q, r);
676 mutex_unlock(&indio_dev->mlock);
681 EXPORT_SYMBOL(st_sensors_sysfs_scale_avail);
683 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
684 MODULE_DESCRIPTION("STMicroelectronics ST-sensors core");
685 MODULE_LICENSE("GPL v2");