2 * STMicroelectronics sensors core library driver
4 * Copyright 2012-2013 STMicroelectronics Inc.
6 * Denis Ciocca <denis.ciocca@st.com>
8 * Licensed under the GPL-2.
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/delay.h>
15 #include <linux/iio/iio.h>
16 #include <linux/regulator/consumer.h>
18 #include <linux/of_device.h>
19 #include <asm/unaligned.h>
20 #include <linux/iio/common/st_sensors.h>
22 #include "st_sensors_core.h"
24 static inline u32 st_sensors_get_unaligned_le24(const u8 *p)
26 return (s32)((p[0] | p[1] << 8 | p[2] << 16) << 8) >> 8;
29 int st_sensors_write_data_with_mask(struct iio_dev *indio_dev,
30 u8 reg_addr, u8 mask, u8 data)
34 struct st_sensor_data *sdata = iio_priv(indio_dev);
36 err = sdata->tf->read_byte(&sdata->tb, sdata->dev, reg_addr, &new_data);
38 goto st_sensors_write_data_with_mask_error;
40 new_data = ((new_data & (~mask)) | ((data << __ffs(mask)) & mask));
41 err = sdata->tf->write_byte(&sdata->tb, sdata->dev, reg_addr, new_data);
43 st_sensors_write_data_with_mask_error:
47 int st_sensors_debugfs_reg_access(struct iio_dev *indio_dev,
48 unsigned reg, unsigned writeval,
51 struct st_sensor_data *sdata = iio_priv(indio_dev);
56 return sdata->tf->write_byte(&sdata->tb, sdata->dev,
57 (u8)reg, (u8)writeval);
59 err = sdata->tf->read_byte(&sdata->tb, sdata->dev, (u8)reg, &readdata);
63 *readval = (unsigned)readdata;
67 EXPORT_SYMBOL(st_sensors_debugfs_reg_access);
69 static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
70 unsigned int odr, struct st_sensor_odr_avl *odr_out)
74 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
75 if (sensor_settings->odr.odr_avl[i].hz == 0)
76 goto st_sensors_match_odr_error;
78 if (sensor_settings->odr.odr_avl[i].hz == odr) {
79 odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
80 odr_out->value = sensor_settings->odr.odr_avl[i].value;
86 st_sensors_match_odr_error:
90 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
93 struct st_sensor_odr_avl odr_out = {0, 0};
94 struct st_sensor_data *sdata = iio_priv(indio_dev);
96 if (!sdata->sensor_settings->odr.addr)
99 err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
101 goto st_sensors_match_odr_error;
103 if ((sdata->sensor_settings->odr.addr ==
104 sdata->sensor_settings->pw.addr) &&
105 (sdata->sensor_settings->odr.mask ==
106 sdata->sensor_settings->pw.mask)) {
107 if (sdata->enabled == true) {
108 err = st_sensors_write_data_with_mask(indio_dev,
109 sdata->sensor_settings->odr.addr,
110 sdata->sensor_settings->odr.mask,
116 err = st_sensors_write_data_with_mask(indio_dev,
117 sdata->sensor_settings->odr.addr,
118 sdata->sensor_settings->odr.mask,
122 sdata->odr = odr_out.hz;
124 st_sensors_match_odr_error:
127 EXPORT_SYMBOL(st_sensors_set_odr);
129 static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
130 unsigned int fs, int *index_fs_avl)
132 int i, ret = -EINVAL;
134 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
135 if (sensor_settings->fs.fs_avl[i].num == 0)
136 goto st_sensors_match_odr_error;
138 if (sensor_settings->fs.fs_avl[i].num == fs) {
145 st_sensors_match_odr_error:
149 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
152 struct st_sensor_data *sdata = iio_priv(indio_dev);
154 if (sdata->sensor_settings->fs.addr == 0)
157 err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
159 goto st_accel_set_fullscale_error;
161 err = st_sensors_write_data_with_mask(indio_dev,
162 sdata->sensor_settings->fs.addr,
163 sdata->sensor_settings->fs.mask,
164 sdata->sensor_settings->fs.fs_avl[i].value);
166 goto st_accel_set_fullscale_error;
168 sdata->current_fullscale = (struct st_sensor_fullscale_avl *)
169 &sdata->sensor_settings->fs.fs_avl[i];
172 st_accel_set_fullscale_error:
173 dev_err(&indio_dev->dev, "failed to set new fullscale.\n");
177 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
182 struct st_sensor_odr_avl odr_out = {0, 0};
183 struct st_sensor_data *sdata = iio_priv(indio_dev);
186 tmp_value = sdata->sensor_settings->pw.value_on;
187 if ((sdata->sensor_settings->odr.addr ==
188 sdata->sensor_settings->pw.addr) &&
189 (sdata->sensor_settings->odr.mask ==
190 sdata->sensor_settings->pw.mask)) {
191 err = st_sensors_match_odr(sdata->sensor_settings,
192 sdata->odr, &odr_out);
194 goto set_enable_error;
195 tmp_value = odr_out.value;
198 err = st_sensors_write_data_with_mask(indio_dev,
199 sdata->sensor_settings->pw.addr,
200 sdata->sensor_settings->pw.mask, tmp_value);
202 goto set_enable_error;
204 sdata->enabled = true;
207 sdata->odr = odr_out.hz;
209 err = st_sensors_write_data_with_mask(indio_dev,
210 sdata->sensor_settings->pw.addr,
211 sdata->sensor_settings->pw.mask,
212 sdata->sensor_settings->pw.value_off);
214 goto set_enable_error;
216 sdata->enabled = false;
222 EXPORT_SYMBOL(st_sensors_set_enable);
224 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
226 struct st_sensor_data *sdata = iio_priv(indio_dev);
229 if (sdata->sensor_settings->enable_axis.addr)
230 err = st_sensors_write_data_with_mask(indio_dev,
231 sdata->sensor_settings->enable_axis.addr,
232 sdata->sensor_settings->enable_axis.mask,
236 EXPORT_SYMBOL(st_sensors_set_axis_enable);
238 int st_sensors_power_enable(struct iio_dev *indio_dev)
240 struct st_sensor_data *pdata = iio_priv(indio_dev);
243 /* Regulators not mandatory, but if requested we should enable them. */
244 pdata->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
245 if (IS_ERR(pdata->vdd)) {
246 dev_err(&indio_dev->dev, "unable to get Vdd supply\n");
247 return PTR_ERR(pdata->vdd);
249 err = regulator_enable(pdata->vdd);
251 dev_warn(&indio_dev->dev,
252 "Failed to enable specified Vdd supply\n");
256 pdata->vdd_io = devm_regulator_get(indio_dev->dev.parent, "vddio");
257 if (IS_ERR(pdata->vdd_io)) {
258 dev_err(&indio_dev->dev, "unable to get Vdd_IO supply\n");
259 err = PTR_ERR(pdata->vdd_io);
260 goto st_sensors_disable_vdd;
262 err = regulator_enable(pdata->vdd_io);
264 dev_warn(&indio_dev->dev,
265 "Failed to enable specified Vdd_IO supply\n");
266 goto st_sensors_disable_vdd;
271 st_sensors_disable_vdd:
272 regulator_disable(pdata->vdd);
275 EXPORT_SYMBOL(st_sensors_power_enable);
277 void st_sensors_power_disable(struct iio_dev *indio_dev)
279 struct st_sensor_data *pdata = iio_priv(indio_dev);
281 regulator_disable(pdata->vdd);
282 regulator_disable(pdata->vdd_io);
284 EXPORT_SYMBOL(st_sensors_power_disable);
286 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
287 struct st_sensors_platform_data *pdata)
289 struct st_sensor_data *sdata = iio_priv(indio_dev);
291 /* Sensor does not support interrupts */
292 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
293 !sdata->sensor_settings->drdy_irq.int2.addr) {
294 if (pdata->drdy_int_pin)
295 dev_info(&indio_dev->dev,
296 "DRDY on pin INT%d specified, but sensor "
297 "does not support interrupts\n",
298 pdata->drdy_int_pin);
302 switch (pdata->drdy_int_pin) {
304 if (!sdata->sensor_settings->drdy_irq.int1.mask) {
305 dev_err(&indio_dev->dev,
306 "DRDY on INT1 not available.\n");
309 sdata->drdy_int_pin = 1;
312 if (!sdata->sensor_settings->drdy_irq.int2.mask) {
313 dev_err(&indio_dev->dev,
314 "DRDY on INT2 not available.\n");
317 sdata->drdy_int_pin = 2;
320 dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n");
324 if (pdata->open_drain) {
325 if (!sdata->sensor_settings->drdy_irq.int1.addr_od &&
326 !sdata->sensor_settings->drdy_irq.int2.addr_od)
327 dev_err(&indio_dev->dev,
328 "open drain requested but unsupported.\n");
330 sdata->int_pin_open_drain = true;
337 static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
338 struct st_sensors_platform_data *defdata)
340 struct st_sensors_platform_data *pdata;
341 struct device_node *np = dev->of_node;
347 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
348 if (!of_property_read_u32(np, "st,drdy-int-pin", &val) && (val <= 2))
349 pdata->drdy_int_pin = (u8) val;
351 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
353 pdata->open_drain = of_property_read_bool(np, "drive-open-drain");
359 * st_sensors_of_name_probe() - device tree probe for ST sensor name
360 * @dev: driver model representation of the device.
361 * @match: the OF match table for the device, containing compatible strings
362 * but also a .data field with the corresponding internal kernel name
363 * used by this sensor.
364 * @name: device name buffer reference.
365 * @len: device name buffer length.
367 * In effect this function matches a compatible string to an internal kernel
368 * name for a certain sensor device, so that the rest of the autodetection can
369 * rely on that name from this point on. I2C/SPI devices will be renamed
370 * to match the internal kernel convention.
372 void st_sensors_of_name_probe(struct device *dev,
373 const struct of_device_id *match,
376 const struct of_device_id *of_id;
378 of_id = of_match_device(match, dev);
379 if (!of_id || !of_id->data)
382 /* The name from the OF match takes precedence if present */
383 strlcpy(name, of_id->data, len);
385 EXPORT_SYMBOL(st_sensors_of_name_probe);
387 static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
388 struct st_sensors_platform_data *defdata)
394 int st_sensors_init_sensor(struct iio_dev *indio_dev,
395 struct st_sensors_platform_data *pdata)
397 struct st_sensor_data *sdata = iio_priv(indio_dev);
398 struct st_sensors_platform_data *of_pdata;
401 /* If OF/DT pdata exists, it will take precedence of anything else */
402 of_pdata = st_sensors_of_probe(indio_dev->dev.parent, pdata);
407 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
412 err = st_sensors_set_enable(indio_dev, false);
416 /* Disable DRDY, this might be still be enabled after reboot. */
417 err = st_sensors_set_dataready_irq(indio_dev, false);
421 if (sdata->current_fullscale) {
422 err = st_sensors_set_fullscale(indio_dev,
423 sdata->current_fullscale->num);
427 dev_info(&indio_dev->dev, "Full-scale not possible\n");
429 err = st_sensors_set_odr(indio_dev, sdata->odr);
434 if (sdata->sensor_settings->bdu.addr) {
435 err = st_sensors_write_data_with_mask(indio_dev,
436 sdata->sensor_settings->bdu.addr,
437 sdata->sensor_settings->bdu.mask, true);
443 if (sdata->sensor_settings->das.addr) {
444 err = st_sensors_write_data_with_mask(indio_dev,
445 sdata->sensor_settings->das.addr,
446 sdata->sensor_settings->das.mask, 1);
451 if (sdata->int_pin_open_drain) {
454 if (sdata->drdy_int_pin == 1) {
455 addr = sdata->sensor_settings->drdy_irq.int1.addr_od;
456 mask = sdata->sensor_settings->drdy_irq.int1.mask_od;
458 addr = sdata->sensor_settings->drdy_irq.int2.addr_od;
459 mask = sdata->sensor_settings->drdy_irq.int2.mask_od;
462 dev_info(&indio_dev->dev,
463 "set interrupt line to open drain mode on pin %d\n",
464 sdata->drdy_int_pin);
465 err = st_sensors_write_data_with_mask(indio_dev, addr,
471 err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
475 EXPORT_SYMBOL(st_sensors_init_sensor);
477 int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
480 u8 drdy_addr, drdy_mask;
481 struct st_sensor_data *sdata = iio_priv(indio_dev);
483 if (!sdata->sensor_settings->drdy_irq.int1.addr &&
484 !sdata->sensor_settings->drdy_irq.int2.addr) {
486 * there are some devices (e.g. LIS3MDL) where drdy line is
487 * routed to a given pin and it is not possible to select a
488 * different one. Take into account irq status register
489 * to understand if irq trigger can be properly supported
491 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr)
492 sdata->hw_irq_trigger = enable;
496 /* Enable/Disable the interrupt generator 1. */
497 if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
498 err = st_sensors_write_data_with_mask(indio_dev,
499 sdata->sensor_settings->drdy_irq.ig1.en_addr,
500 sdata->sensor_settings->drdy_irq.ig1.en_mask,
503 goto st_accel_set_dataready_irq_error;
506 if (sdata->drdy_int_pin == 1) {
507 drdy_addr = sdata->sensor_settings->drdy_irq.int1.addr;
508 drdy_mask = sdata->sensor_settings->drdy_irq.int1.mask;
510 drdy_addr = sdata->sensor_settings->drdy_irq.int2.addr;
511 drdy_mask = sdata->sensor_settings->drdy_irq.int2.mask;
514 /* Flag to the poll function that the hardware trigger is in use */
515 sdata->hw_irq_trigger = enable;
517 /* Enable/Disable the interrupt generator for data ready. */
518 err = st_sensors_write_data_with_mask(indio_dev, drdy_addr,
519 drdy_mask, (int)enable);
521 st_accel_set_dataready_irq_error:
524 EXPORT_SYMBOL(st_sensors_set_dataready_irq);
526 int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
528 int err = -EINVAL, i;
529 struct st_sensor_data *sdata = iio_priv(indio_dev);
531 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
532 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
533 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
539 goto st_sensors_match_scale_error;
541 err = st_sensors_set_fullscale(indio_dev,
542 sdata->sensor_settings->fs.fs_avl[i].num);
544 st_sensors_match_scale_error:
547 EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain);
549 static int st_sensors_read_axis_data(struct iio_dev *indio_dev,
550 struct iio_chan_spec const *ch, int *data)
554 struct st_sensor_data *sdata = iio_priv(indio_dev);
555 unsigned int byte_for_channel;
557 byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits +
558 ch->scan_type.shift, 8);
559 outdata = kmalloc(byte_for_channel, GFP_KERNEL);
563 err = sdata->tf->read_multiple_byte(&sdata->tb, sdata->dev,
564 ch->address, byte_for_channel,
565 outdata, sdata->multiread_bit);
567 goto st_sensors_free_memory;
569 if (byte_for_channel == 1)
570 *data = (s8)*outdata;
571 else if (byte_for_channel == 2)
572 *data = (s16)get_unaligned_le16(outdata);
573 else if (byte_for_channel == 3)
574 *data = (s32)st_sensors_get_unaligned_le24(outdata);
576 st_sensors_free_memory:
582 int st_sensors_read_info_raw(struct iio_dev *indio_dev,
583 struct iio_chan_spec const *ch, int *val)
586 struct st_sensor_data *sdata = iio_priv(indio_dev);
588 mutex_lock(&indio_dev->mlock);
589 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
593 err = st_sensors_set_enable(indio_dev, true);
597 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
598 err = st_sensors_read_axis_data(indio_dev, ch, val);
602 *val = *val >> ch->scan_type.shift;
604 err = st_sensors_set_enable(indio_dev, false);
607 mutex_unlock(&indio_dev->mlock);
611 EXPORT_SYMBOL(st_sensors_read_info_raw);
613 static int st_sensors_init_interface_mode(struct iio_dev *indio_dev,
614 const struct st_sensor_settings *sensor_settings)
616 struct st_sensor_data *sdata = iio_priv(indio_dev);
617 struct device_node *np = sdata->dev->of_node;
618 struct st_sensors_platform_data *pdata;
620 pdata = (struct st_sensors_platform_data *)sdata->dev->platform_data;
621 if (((np && of_property_read_bool(np, "spi-3wire")) ||
622 (pdata && pdata->spi_3wire)) && sensor_settings->sim.addr) {
625 err = sdata->tf->write_byte(&sdata->tb, sdata->dev,
626 sensor_settings->sim.addr,
627 sensor_settings->sim.value);
629 dev_err(&indio_dev->dev,
630 "failed to init interface mode\n");
638 int st_sensors_check_device_support(struct iio_dev *indio_dev,
639 int num_sensors_list,
640 const struct st_sensor_settings *sensor_settings)
644 struct st_sensor_data *sdata = iio_priv(indio_dev);
646 for (i = 0; i < num_sensors_list; i++) {
647 for (n = 0; n < ST_SENSORS_MAX_4WAI; n++) {
648 if (strcmp(indio_dev->name,
649 sensor_settings[i].sensors_supported[n]) == 0) {
653 if (n < ST_SENSORS_MAX_4WAI)
656 if (i == num_sensors_list) {
657 dev_err(&indio_dev->dev, "device name %s not recognized.\n",
662 err = st_sensors_init_interface_mode(indio_dev, &sensor_settings[i]);
666 if (sensor_settings[i].wai_addr) {
667 err = sdata->tf->read_byte(&sdata->tb, sdata->dev,
668 sensor_settings[i].wai_addr, &wai);
670 dev_err(&indio_dev->dev,
671 "failed to read Who-Am-I register.\n");
675 if (sensor_settings[i].wai != wai) {
676 dev_err(&indio_dev->dev,
677 "%s: WhoAmI mismatch (0x%x).\n",
678 indio_dev->name, wai);
683 sdata->sensor_settings =
684 (struct st_sensor_settings *)&sensor_settings[i];
688 EXPORT_SYMBOL(st_sensors_check_device_support);
690 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
691 struct device_attribute *attr, char *buf)
694 struct iio_dev *indio_dev = dev_get_drvdata(dev);
695 struct st_sensor_data *sdata = iio_priv(indio_dev);
697 mutex_lock(&indio_dev->mlock);
698 for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
699 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
702 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
703 sdata->sensor_settings->odr.odr_avl[i].hz);
705 mutex_unlock(&indio_dev->mlock);
710 EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail);
712 ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
713 struct device_attribute *attr, char *buf)
715 int i, len = 0, q, r;
716 struct iio_dev *indio_dev = dev_get_drvdata(dev);
717 struct st_sensor_data *sdata = iio_priv(indio_dev);
719 mutex_lock(&indio_dev->mlock);
720 for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
721 if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
724 q = sdata->sensor_settings->fs.fs_avl[i].gain / 1000000;
725 r = sdata->sensor_settings->fs.fs_avl[i].gain % 1000000;
727 len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", q, r);
729 mutex_unlock(&indio_dev->mlock);
734 EXPORT_SYMBOL(st_sensors_sysfs_scale_avail);
736 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
737 MODULE_DESCRIPTION("STMicroelectronics ST-sensors core");
738 MODULE_LICENSE("GPL v2");