2 * STMicroelectronics st_lsm6dsx i2c controller driver
4 * i2c controller embedded in lsm6dx series can connect up to four
5 * slave devices using accelerometer sensor as trigger for i2c
6 * read/write operations. Current implementation relies on SLV0 channel
7 * for slave configuration and SLV{1,2,3} to read data and push them into
10 * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
12 * Permission to use, copy, modify, and/or distribute this software for any
13 * purpose with or without fee is hereby granted, provided that the above
14 * copyright notice and this permission notice appear in all copies.
16 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
17 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
19 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
20 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
21 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
22 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 #include <linux/module.h>
26 #include <linux/regmap.h>
27 #include <linux/iio/iio.h>
28 #include <linux/iio/sysfs.h>
29 #include <linux/bitfield.h>
31 #include "st_lsm6dsx.h"
33 #define ST_LSM6DSX_SLV_ADDR(n, base) ((base) + (n) * 3)
34 #define ST_LSM6DSX_SLV_SUB_ADDR(n, base) ((base) + 1 + (n) * 3)
35 #define ST_LSM6DSX_SLV_CONFIG(n, base) ((base) + 2 + (n) * 3)
37 #define ST_LS6DSX_READ_OP_MASK GENMASK(2, 0)
39 static const struct st_lsm6dsx_ext_dev_settings st_lsm6dsx_ext_dev_table[] = {
47 .id = ST_LSM6DSX_ID_MAGN,
51 .mask = GENMASK(3, 2),
53 .odr_avl[0] = { 10000, 0x0 },
54 .odr_avl[1] = { 20000, 0x1 },
55 .odr_avl[2] = { 50000, 0x2 },
56 .odr_avl[3] = { 100000, 0x3 },
73 .mask = GENMASK(1, 0),
98 .id = ST_LSM6DSX_ID_MAGN,
102 .mask = GENMASK(4, 2),
104 .odr_avl[0] = { 1000, 0x0 },
105 .odr_avl[1] = { 2000, 0x1 },
106 .odr_avl[2] = { 3000, 0x2 },
107 .odr_avl[3] = { 5000, 0x3 },
108 .odr_avl[4] = { 10000, 0x4 },
109 .odr_avl[5] = { 20000, 0x5 },
110 .odr_avl[6] = { 40000, 0x6 },
111 .odr_avl[7] = { 80000, 0x7 },
117 .mask = GENMASK(6, 5),
130 }, /* 12000 uG/LSB */
134 }, /* 16000 uG/LSB */
140 .mask = GENMASK(1, 0),
156 static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)
158 struct st_lsm6dsx_sensor *sensor;
161 sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
162 odr = (hw->enable_mask & BIT(ST_LSM6DSX_ID_ACC)) ? sensor->odr : 12500;
163 /* set 10ms as minimum timeout for i2c slave configuration */
164 timeout = max_t(u32, 2000000U / odr + 1, 10);
169 * st_lsm6dsx_shub_read_output - read i2c controller register
171 * Read st_lsm6dsx i2c controller register
173 int st_lsm6dsx_shub_read_output(struct st_lsm6dsx_hw *hw, u8 *data, int len)
175 const struct st_lsm6dsx_shub_settings *hub_settings;
178 mutex_lock(&hw->page_lock);
180 hub_settings = &hw->settings->shub_settings;
181 if (hub_settings->shub_out.sec_page) {
182 err = st_lsm6dsx_set_page(hw, true);
187 err = regmap_bulk_read(hw->regmap, hub_settings->shub_out.addr,
190 if (hub_settings->shub_out.sec_page)
191 st_lsm6dsx_set_page(hw, false);
193 mutex_unlock(&hw->page_lock);
199 * st_lsm6dsx_shub_write_reg - write i2c controller register
201 * Write st_lsm6dsx i2c controller register
203 static int st_lsm6dsx_shub_write_reg(struct st_lsm6dsx_hw *hw, u8 addr,
208 mutex_lock(&hw->page_lock);
209 err = st_lsm6dsx_set_page(hw, true);
213 err = regmap_bulk_write(hw->regmap, addr, data, len);
215 st_lsm6dsx_set_page(hw, false);
217 mutex_unlock(&hw->page_lock);
223 st_lsm6dsx_shub_write_reg_with_mask(struct st_lsm6dsx_hw *hw, u8 addr,
228 mutex_lock(&hw->page_lock);
229 err = st_lsm6dsx_set_page(hw, true);
233 err = regmap_update_bits(hw->regmap, addr, mask, val);
235 st_lsm6dsx_set_page(hw, false);
237 mutex_unlock(&hw->page_lock);
242 static int st_lsm6dsx_shub_master_enable(struct st_lsm6dsx_sensor *sensor,
245 const struct st_lsm6dsx_shub_settings *hub_settings;
246 struct st_lsm6dsx_hw *hw = sensor->hw;
250 /* enable acc sensor as trigger */
251 err = st_lsm6dsx_sensor_set_enable(sensor, enable);
255 mutex_lock(&hw->page_lock);
257 hub_settings = &hw->settings->shub_settings;
258 if (hub_settings->master_en.sec_page) {
259 err = st_lsm6dsx_set_page(hw, true);
264 data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->master_en.mask);
265 err = regmap_update_bits(hw->regmap, hub_settings->master_en.addr,
266 hub_settings->master_en.mask, data);
268 if (hub_settings->master_en.sec_page)
269 st_lsm6dsx_set_page(hw, false);
271 mutex_unlock(&hw->page_lock);
277 * st_lsm6dsx_shub_read - read data from slave device register
279 * Read data from slave device register. SLV0 is used for
280 * one-shot read operation
283 st_lsm6dsx_shub_read(struct st_lsm6dsx_sensor *sensor, u8 addr,
286 const struct st_lsm6dsx_shub_settings *hub_settings;
287 u8 config[3], slv_addr, slv_config = 0;
288 struct st_lsm6dsx_hw *hw = sensor->hw;
289 const struct st_lsm6dsx_reg *aux_sens;
292 hub_settings = &hw->settings->shub_settings;
293 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
294 aux_sens = &hw->settings->shub_settings.aux_sens;
295 /* do not overwrite aux_sens */
296 if (slv_addr + 2 == aux_sens->addr)
297 slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
299 config[0] = (sensor->ext_info.addr << 1) | 1;
301 config[2] = (len & ST_LS6DSX_READ_OP_MASK) | slv_config;
303 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
308 err = st_lsm6dsx_shub_master_enable(sensor, true);
312 st_lsm6dsx_shub_wait_complete(hw);
314 err = st_lsm6dsx_shub_read_output(hw, data,
315 len & ST_LS6DSX_READ_OP_MASK);
319 st_lsm6dsx_shub_master_enable(sensor, false);
321 config[0] = hub_settings->pause;
323 config[2] = slv_config;
324 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
329 * st_lsm6dsx_shub_write - write data to slave device register
331 * Write data from slave device register. SLV0 is used for
332 * one-shot write operation
335 st_lsm6dsx_shub_write(struct st_lsm6dsx_sensor *sensor, u8 addr,
338 const struct st_lsm6dsx_shub_settings *hub_settings;
339 struct st_lsm6dsx_hw *hw = sensor->hw;
340 u8 config[2], slv_addr;
343 hub_settings = &hw->settings->shub_settings;
344 if (hub_settings->wr_once.addr) {
347 data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->wr_once.mask);
348 err = st_lsm6dsx_shub_write_reg_with_mask(hw,
349 hub_settings->wr_once.addr,
350 hub_settings->wr_once.mask,
356 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
357 config[0] = sensor->ext_info.addr << 1;
358 for (i = 0 ; i < len; i++) {
359 config[1] = addr + i;
361 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
366 err = st_lsm6dsx_shub_write_reg(hw, hub_settings->dw_slv0_addr,
371 err = st_lsm6dsx_shub_master_enable(sensor, true);
375 st_lsm6dsx_shub_wait_complete(hw);
377 st_lsm6dsx_shub_master_enable(sensor, false);
380 config[0] = hub_settings->pause;
382 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, sizeof(config));
386 st_lsm6dsx_shub_write_with_mask(struct st_lsm6dsx_sensor *sensor,
387 u8 addr, u8 mask, u8 val)
392 err = st_lsm6dsx_shub_read(sensor, addr, &data, sizeof(data));
396 data = ((data & ~mask) | (val << __ffs(mask) & mask));
398 return st_lsm6dsx_shub_write(sensor, addr, &data, sizeof(data));
402 st_lsm6dsx_shub_get_odr_val(struct st_lsm6dsx_sensor *sensor,
405 const struct st_lsm6dsx_ext_dev_settings *settings;
408 settings = sensor->ext_info.settings;
409 for (i = 0; i < settings->odr_table.odr_len; i++) {
410 if (settings->odr_table.odr_avl[i].milli_hz == odr)
414 if (i == settings->odr_table.odr_len)
417 *val = settings->odr_table.odr_avl[i].val;
422 st_lsm6dsx_shub_set_odr(struct st_lsm6dsx_sensor *sensor, u32 odr)
424 const struct st_lsm6dsx_ext_dev_settings *settings;
428 err = st_lsm6dsx_shub_get_odr_val(sensor, odr, &val);
432 settings = sensor->ext_info.settings;
433 return st_lsm6dsx_shub_write_with_mask(sensor,
434 settings->odr_table.reg.addr,
435 settings->odr_table.reg.mask,
439 /* use SLV{1,2,3} for FIFO read operations */
441 st_lsm6dsx_shub_config_channels(struct st_lsm6dsx_sensor *sensor,
444 const struct st_lsm6dsx_shub_settings *hub_settings;
445 const struct st_lsm6dsx_ext_dev_settings *settings;
446 u8 config[9] = {}, enable_mask, slv_addr;
447 struct st_lsm6dsx_hw *hw = sensor->hw;
448 struct st_lsm6dsx_sensor *cur_sensor;
451 hub_settings = &hw->settings->shub_settings;
453 enable_mask = hw->enable_mask | BIT(sensor->id);
455 enable_mask = hw->enable_mask & ~BIT(sensor->id);
457 for (i = ST_LSM6DSX_ID_EXT0; i <= ST_LSM6DSX_ID_EXT2; i++) {
458 if (!hw->iio_devs[i])
461 cur_sensor = iio_priv(hw->iio_devs[i]);
462 if (!(enable_mask & BIT(cur_sensor->id)))
465 settings = cur_sensor->ext_info.settings;
466 config[j] = (sensor->ext_info.addr << 1) | 1;
467 config[j + 1] = settings->out.addr;
468 config[j + 2] = (settings->out.len & ST_LS6DSX_READ_OP_MASK) |
469 hub_settings->batch_en;
473 slv_addr = ST_LSM6DSX_SLV_ADDR(1, hub_settings->slv0_addr);
474 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
478 int st_lsm6dsx_shub_set_enable(struct st_lsm6dsx_sensor *sensor, bool enable)
480 const struct st_lsm6dsx_ext_dev_settings *settings;
483 err = st_lsm6dsx_shub_config_channels(sensor, enable);
487 settings = sensor->ext_info.settings;
489 err = st_lsm6dsx_shub_set_odr(sensor,
490 sensor->ext_info.slv_odr);
494 err = st_lsm6dsx_shub_write_with_mask(sensor,
495 settings->odr_table.reg.addr,
496 settings->odr_table.reg.mask, 0);
501 if (settings->pwr_table.reg.addr) {
504 val = enable ? settings->pwr_table.on_val
505 : settings->pwr_table.off_val;
506 err = st_lsm6dsx_shub_write_with_mask(sensor,
507 settings->pwr_table.reg.addr,
508 settings->pwr_table.reg.mask, val);
513 return st_lsm6dsx_shub_master_enable(sensor, enable);
517 st_lsm6dsx_shub_read_oneshot(struct st_lsm6dsx_sensor *sensor,
518 struct iio_chan_spec const *ch,
524 err = st_lsm6dsx_shub_set_enable(sensor, true);
528 delay = 1000000000 / sensor->ext_info.slv_odr;
529 usleep_range(delay, 2 * delay);
531 len = min_t(int, sizeof(data), ch->scan_type.realbits >> 3);
532 err = st_lsm6dsx_shub_read(sensor, ch->address, data, len);
536 err = st_lsm6dsx_shub_set_enable(sensor, false);
542 *val = (s16)le16_to_cpu(*((__le16 *)data));
552 st_lsm6dsx_shub_read_raw(struct iio_dev *iio_dev,
553 struct iio_chan_spec const *ch,
554 int *val, int *val2, long mask)
556 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
560 case IIO_CHAN_INFO_RAW:
561 ret = iio_device_claim_direct_mode(iio_dev);
565 ret = st_lsm6dsx_shub_read_oneshot(sensor, ch, val);
566 iio_device_release_direct_mode(iio_dev);
568 case IIO_CHAN_INFO_SAMP_FREQ:
569 *val = sensor->ext_info.slv_odr / 1000;
570 *val2 = (sensor->ext_info.slv_odr % 1000) * 1000;
571 ret = IIO_VAL_INT_PLUS_MICRO;
573 case IIO_CHAN_INFO_SCALE:
575 *val2 = sensor->gain;
576 ret = IIO_VAL_INT_PLUS_MICRO;
587 st_lsm6dsx_shub_set_full_scale(struct st_lsm6dsx_sensor *sensor,
590 const struct st_lsm6dsx_fs_table_entry *fs_table;
593 fs_table = &sensor->ext_info.settings->fs_table;
594 if (!fs_table->reg.addr)
597 for (i = 0; i < fs_table->fs_len; i++) {
598 if (fs_table->fs_avl[i].gain == gain)
602 if (i == fs_table->fs_len)
605 err = st_lsm6dsx_shub_write_with_mask(sensor, fs_table->reg.addr,
607 fs_table->fs_avl[i].val);
617 st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev,
618 struct iio_chan_spec const *chan,
619 int val, int val2, long mask)
621 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
624 err = iio_device_claim_direct_mode(iio_dev);
629 case IIO_CHAN_INFO_SAMP_FREQ: {
632 val = val * 1000 + val2 / 1000;
633 err = st_lsm6dsx_shub_get_odr_val(sensor, val, &data);
635 struct st_lsm6dsx_hw *hw = sensor->hw;
636 struct st_lsm6dsx_sensor *ref_sensor;
640 ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
641 odr = st_lsm6dsx_check_odr(ref_sensor, val, &odr_val);
647 sensor->ext_info.slv_odr = val;
652 case IIO_CHAN_INFO_SCALE:
653 err = st_lsm6dsx_shub_set_full_scale(sensor, val2);
661 iio_device_release_direct_mode(iio_dev);
667 st_lsm6dsx_shub_sampling_freq_avail(struct device *dev,
668 struct device_attribute *attr,
671 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
672 const struct st_lsm6dsx_ext_dev_settings *settings;
675 settings = sensor->ext_info.settings;
676 for (i = 0; i < settings->odr_table.odr_len; i++) {
677 u32 val = settings->odr_table.odr_avl[i].milli_hz;
679 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%03d ",
680 val / 1000, val % 1000);
687 static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev,
688 struct device_attribute *attr,
691 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
692 const struct st_lsm6dsx_ext_dev_settings *settings;
695 settings = sensor->ext_info.settings;
696 for (i = 0; i < settings->fs_table.fs_len; i++)
697 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
698 settings->fs_table.fs_avl[i].gain);
704 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_shub_sampling_freq_avail);
705 static IIO_DEVICE_ATTR(in_scale_available, 0444,
706 st_lsm6dsx_shub_scale_avail, NULL, 0);
707 static struct attribute *st_lsm6dsx_shub_attributes[] = {
708 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
709 &iio_dev_attr_in_scale_available.dev_attr.attr,
713 static const struct attribute_group st_lsm6dsx_shub_attribute_group = {
714 .attrs = st_lsm6dsx_shub_attributes,
717 static const struct iio_info st_lsm6dsx_shub_info = {
718 .attrs = &st_lsm6dsx_shub_attribute_group,
719 .read_raw = st_lsm6dsx_shub_read_raw,
720 .write_raw = st_lsm6dsx_shub_write_raw,
721 .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
724 static struct iio_dev *
725 st_lsm6dsx_shub_alloc_iiodev(struct st_lsm6dsx_hw *hw,
726 enum st_lsm6dsx_sensor_id id,
727 const struct st_lsm6dsx_ext_dev_settings *info,
728 u8 i2c_addr, const char *name)
730 enum st_lsm6dsx_sensor_id ref_id = ST_LSM6DSX_ID_ACC;
731 struct iio_chan_spec *ext_channels;
732 struct st_lsm6dsx_sensor *sensor;
733 struct iio_dev *iio_dev;
735 iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor));
739 iio_dev->modes = INDIO_DIRECT_MODE;
740 iio_dev->info = &st_lsm6dsx_shub_info;
742 sensor = iio_priv(iio_dev);
745 sensor->odr = hw->settings->odr_table[ref_id].odr_avl[0].milli_hz;
746 sensor->ext_info.slv_odr = info->odr_table.odr_avl[0].milli_hz;
747 sensor->gain = info->fs_table.fs_avl[0].gain;
748 sensor->ext_info.settings = info;
749 sensor->ext_info.addr = i2c_addr;
750 sensor->watermark = 1;
753 case ST_LSM6DSX_ID_MAGN: {
754 const struct iio_chan_spec magn_channels[] = {
755 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr,
757 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 2,
759 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 4,
761 IIO_CHAN_SOFT_TIMESTAMP(3),
764 ext_channels = devm_kzalloc(hw->dev, sizeof(magn_channels),
769 memcpy(ext_channels, magn_channels, sizeof(magn_channels));
770 iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks;
771 iio_dev->channels = ext_channels;
772 iio_dev->num_channels = ARRAY_SIZE(magn_channels);
774 scnprintf(sensor->name, sizeof(sensor->name), "%s_magn",
781 iio_dev->name = sensor->name;
786 static int st_lsm6dsx_shub_init_device(struct st_lsm6dsx_sensor *sensor)
788 const struct st_lsm6dsx_ext_dev_settings *settings;
791 settings = sensor->ext_info.settings;
792 if (settings->bdu.addr) {
793 err = st_lsm6dsx_shub_write_with_mask(sensor,
795 settings->bdu.mask, 1);
800 if (settings->temp_comp.addr) {
801 err = st_lsm6dsx_shub_write_with_mask(sensor,
802 settings->temp_comp.addr,
803 settings->temp_comp.mask, 1);
808 if (settings->off_canc.addr) {
809 err = st_lsm6dsx_shub_write_with_mask(sensor,
810 settings->off_canc.addr,
811 settings->off_canc.mask, 1);
820 st_lsm6dsx_shub_check_wai(struct st_lsm6dsx_hw *hw, u8 *i2c_addr,
821 const struct st_lsm6dsx_ext_dev_settings *settings)
823 const struct st_lsm6dsx_shub_settings *hub_settings;
824 u8 config[3], data, slv_addr, slv_config = 0;
825 const struct st_lsm6dsx_reg *aux_sens;
826 struct st_lsm6dsx_sensor *sensor;
830 sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
831 hub_settings = &hw->settings->shub_settings;
832 aux_sens = &hw->settings->shub_settings.aux_sens;
833 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
834 /* do not overwrite aux_sens */
835 if (slv_addr + 2 == aux_sens->addr)
836 slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
838 for (i = 0; i < ARRAY_SIZE(settings->i2c_addr); i++) {
839 if (!settings->i2c_addr[i])
842 /* read wai slave register */
843 config[0] = (settings->i2c_addr[i] << 1) | 0x1;
844 config[1] = settings->wai.addr;
845 config[2] = 0x1 | slv_config;
847 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
852 err = st_lsm6dsx_shub_master_enable(sensor, true);
856 st_lsm6dsx_shub_wait_complete(hw);
858 err = st_lsm6dsx_shub_read_output(hw, &data, sizeof(data));
860 st_lsm6dsx_shub_master_enable(sensor, false);
865 if (data != settings->wai.val)
868 *i2c_addr = settings->i2c_addr[i];
873 /* reset SLV0 channel */
874 config[0] = hub_settings->pause;
876 config[2] = slv_config;
877 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
882 return found ? 0 : -ENODEV;
885 int st_lsm6dsx_shub_probe(struct st_lsm6dsx_hw *hw, const char *name)
887 enum st_lsm6dsx_sensor_id id = ST_LSM6DSX_ID_EXT0;
888 struct st_lsm6dsx_sensor *sensor;
889 int err, i, num_ext_dev = 0;
892 for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_ext_dev_table); i++) {
893 err = st_lsm6dsx_shub_check_wai(hw, &i2c_addr,
894 &st_lsm6dsx_ext_dev_table[i]);
900 hw->iio_devs[id] = st_lsm6dsx_shub_alloc_iiodev(hw, id,
901 &st_lsm6dsx_ext_dev_table[i],
903 if (!hw->iio_devs[id])
906 sensor = iio_priv(hw->iio_devs[id]);
907 err = st_lsm6dsx_shub_init_device(sensor);
911 if (++num_ext_dev >= hw->settings->shub_settings.num_ext_dev)