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),
93 static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)
95 struct st_lsm6dsx_sensor *sensor;
98 sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
99 odr = (hw->enable_mask & BIT(ST_LSM6DSX_ID_ACC)) ? sensor->odr : 12500;
100 msleep((2000000U / odr) + 1);
104 * st_lsm6dsx_shub_read_reg - read i2c controller register
106 * Read st_lsm6dsx i2c controller register
109 st_lsm6dsx_shub_read_reg(struct st_lsm6dsx_hw *hw, u8 *data,
112 const struct st_lsm6dsx_shub_settings *hub_settings;
115 mutex_lock(&hw->page_lock);
117 hub_settings = &hw->settings->shub_settings;
118 if (hub_settings->shub_out.sec_page) {
119 err = st_lsm6dsx_set_page(hw, true);
124 err = regmap_bulk_read(hw->regmap, hub_settings->shub_out.addr,
127 if (hub_settings->shub_out.sec_page)
128 st_lsm6dsx_set_page(hw, false);
130 mutex_unlock(&hw->page_lock);
136 * st_lsm6dsx_shub_write_reg - write i2c controller register
138 * Write st_lsm6dsx i2c controller register
140 static int st_lsm6dsx_shub_write_reg(struct st_lsm6dsx_hw *hw, u8 addr,
145 mutex_lock(&hw->page_lock);
146 err = st_lsm6dsx_set_page(hw, true);
150 err = regmap_bulk_write(hw->regmap, addr, data, len);
152 st_lsm6dsx_set_page(hw, false);
154 mutex_unlock(&hw->page_lock);
160 st_lsm6dsx_shub_write_reg_with_mask(struct st_lsm6dsx_hw *hw, u8 addr,
165 mutex_lock(&hw->page_lock);
166 err = st_lsm6dsx_set_page(hw, true);
170 err = regmap_update_bits(hw->regmap, addr, mask, val);
172 st_lsm6dsx_set_page(hw, false);
174 mutex_unlock(&hw->page_lock);
179 static int st_lsm6dsx_shub_master_enable(struct st_lsm6dsx_sensor *sensor,
182 const struct st_lsm6dsx_shub_settings *hub_settings;
183 struct st_lsm6dsx_hw *hw = sensor->hw;
187 /* enable acc sensor as trigger */
188 err = st_lsm6dsx_sensor_set_enable(sensor, enable);
192 mutex_lock(&hw->page_lock);
194 hub_settings = &hw->settings->shub_settings;
195 if (hub_settings->master_en.sec_page) {
196 err = st_lsm6dsx_set_page(hw, true);
201 data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->master_en.mask);
202 err = regmap_update_bits(hw->regmap, hub_settings->master_en.addr,
203 hub_settings->master_en.mask, data);
205 if (hub_settings->master_en.sec_page)
206 st_lsm6dsx_set_page(hw, false);
208 mutex_unlock(&hw->page_lock);
214 * st_lsm6dsx_shub_read - read data from slave device register
216 * Read data from slave device register. SLV0 is used for
217 * one-shot read operation
220 st_lsm6dsx_shub_read(struct st_lsm6dsx_sensor *sensor, u8 addr,
223 const struct st_lsm6dsx_shub_settings *hub_settings;
224 struct st_lsm6dsx_hw *hw = sensor->hw;
225 u8 config[3], slv_addr;
228 hub_settings = &hw->settings->shub_settings;
229 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
231 config[0] = (sensor->ext_info.addr << 1) | 1;
233 config[2] = len & ST_LS6DSX_READ_OP_MASK;
235 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
240 err = st_lsm6dsx_shub_master_enable(sensor, true);
244 st_lsm6dsx_shub_wait_complete(hw);
246 err = st_lsm6dsx_shub_read_reg(hw, data, len & ST_LS6DSX_READ_OP_MASK);
248 st_lsm6dsx_shub_master_enable(sensor, false);
250 memset(config, 0, sizeof(config));
251 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
256 * st_lsm6dsx_shub_write - write data to slave device register
258 * Write data from slave device register. SLV0 is used for
259 * one-shot write operation
262 st_lsm6dsx_shub_write(struct st_lsm6dsx_sensor *sensor, u8 addr,
265 const struct st_lsm6dsx_shub_settings *hub_settings;
266 struct st_lsm6dsx_hw *hw = sensor->hw;
267 u8 config[2], slv_addr;
270 hub_settings = &hw->settings->shub_settings;
271 if (hub_settings->wr_once.addr) {
274 data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->wr_once.mask);
275 err = st_lsm6dsx_shub_write_reg_with_mask(hw,
276 hub_settings->wr_once.addr,
277 hub_settings->wr_once.mask,
283 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
284 config[0] = sensor->ext_info.addr << 1;
285 for (i = 0 ; i < len; i++) {
286 config[1] = addr + i;
288 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
293 err = st_lsm6dsx_shub_write_reg(hw, hub_settings->dw_slv0_addr,
298 err = st_lsm6dsx_shub_master_enable(sensor, true);
302 st_lsm6dsx_shub_wait_complete(hw);
304 st_lsm6dsx_shub_master_enable(sensor, false);
307 memset(config, 0, sizeof(config));
308 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, sizeof(config));
312 st_lsm6dsx_shub_write_with_mask(struct st_lsm6dsx_sensor *sensor,
313 u8 addr, u8 mask, u8 val)
318 err = st_lsm6dsx_shub_read(sensor, addr, &data, sizeof(data));
322 data = ((data & ~mask) | (val << __ffs(mask) & mask));
324 return st_lsm6dsx_shub_write(sensor, addr, &data, sizeof(data));
328 st_lsm6dsx_shub_get_odr_val(struct st_lsm6dsx_sensor *sensor,
331 const struct st_lsm6dsx_ext_dev_settings *settings;
334 settings = sensor->ext_info.settings;
335 for (i = 0; i < settings->odr_table.odr_len; i++) {
336 if (settings->odr_table.odr_avl[i].milli_hz == odr)
340 if (i == settings->odr_table.odr_len)
343 *val = settings->odr_table.odr_avl[i].val;
348 st_lsm6dsx_shub_set_odr(struct st_lsm6dsx_sensor *sensor, u32 odr)
350 const struct st_lsm6dsx_ext_dev_settings *settings;
354 err = st_lsm6dsx_shub_get_odr_val(sensor, odr, &val);
358 settings = sensor->ext_info.settings;
359 return st_lsm6dsx_shub_write_with_mask(sensor,
360 settings->odr_table.reg.addr,
361 settings->odr_table.reg.mask,
365 /* use SLV{1,2,3} for FIFO read operations */
367 st_lsm6dsx_shub_config_channels(struct st_lsm6dsx_sensor *sensor,
370 const struct st_lsm6dsx_shub_settings *hub_settings;
371 const struct st_lsm6dsx_ext_dev_settings *settings;
372 u8 config[9] = {}, enable_mask, slv_addr;
373 struct st_lsm6dsx_hw *hw = sensor->hw;
374 struct st_lsm6dsx_sensor *cur_sensor;
377 hub_settings = &hw->settings->shub_settings;
379 enable_mask = hw->enable_mask | BIT(sensor->id);
381 enable_mask = hw->enable_mask & ~BIT(sensor->id);
383 for (i = ST_LSM6DSX_ID_EXT0; i <= ST_LSM6DSX_ID_EXT2; i++) {
384 if (!hw->iio_devs[i])
387 cur_sensor = iio_priv(hw->iio_devs[i]);
388 if (!(enable_mask & BIT(cur_sensor->id)))
391 settings = cur_sensor->ext_info.settings;
392 config[j] = (sensor->ext_info.addr << 1) | 1;
393 config[j + 1] = settings->out.addr;
394 config[j + 2] = (settings->out.len & ST_LS6DSX_READ_OP_MASK) |
395 hub_settings->batch_en;
399 slv_addr = ST_LSM6DSX_SLV_ADDR(1, hub_settings->slv0_addr);
400 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
404 int st_lsm6dsx_shub_set_enable(struct st_lsm6dsx_sensor *sensor, bool enable)
406 const struct st_lsm6dsx_ext_dev_settings *settings;
409 err = st_lsm6dsx_shub_config_channels(sensor, enable);
413 settings = sensor->ext_info.settings;
415 err = st_lsm6dsx_shub_set_odr(sensor, sensor->odr);
419 err = st_lsm6dsx_shub_write_with_mask(sensor,
420 settings->odr_table.reg.addr,
421 settings->odr_table.reg.mask, 0);
426 if (settings->pwr_table.reg.addr) {
429 val = enable ? settings->pwr_table.on_val
430 : settings->pwr_table.off_val;
431 err = st_lsm6dsx_shub_write_with_mask(sensor,
432 settings->pwr_table.reg.addr,
433 settings->pwr_table.reg.mask, val);
438 return st_lsm6dsx_shub_master_enable(sensor, enable);
442 st_lsm6dsx_shub_read_oneshot(struct st_lsm6dsx_sensor *sensor,
443 struct iio_chan_spec const *ch,
449 err = st_lsm6dsx_shub_set_enable(sensor, true);
453 delay = 1000000000 / sensor->odr;
454 usleep_range(delay, 2 * delay);
456 len = min_t(int, sizeof(data), ch->scan_type.realbits >> 3);
457 err = st_lsm6dsx_shub_read(sensor, ch->address, data, len);
459 st_lsm6dsx_shub_set_enable(sensor, false);
466 *val = (s16)le16_to_cpu(*((__le16 *)data));
476 st_lsm6dsx_shub_read_raw(struct iio_dev *iio_dev,
477 struct iio_chan_spec const *ch,
478 int *val, int *val2, long mask)
480 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
484 case IIO_CHAN_INFO_RAW:
485 ret = iio_device_claim_direct_mode(iio_dev);
489 ret = st_lsm6dsx_shub_read_oneshot(sensor, ch, val);
490 iio_device_release_direct_mode(iio_dev);
492 case IIO_CHAN_INFO_SAMP_FREQ:
493 *val = sensor->odr / 1000;
494 *val2 = (sensor->odr % 1000) * 1000;
495 ret = IIO_VAL_INT_PLUS_MICRO;
497 case IIO_CHAN_INFO_SCALE:
499 *val2 = sensor->gain;
500 ret = IIO_VAL_INT_PLUS_MICRO;
511 st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev,
512 struct iio_chan_spec const *chan,
513 int val, int val2, long mask)
515 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
518 err = iio_device_claim_direct_mode(iio_dev);
523 case IIO_CHAN_INFO_SAMP_FREQ: {
526 val = val * 1000 + val2 / 1000;
527 err = st_lsm6dsx_shub_get_odr_val(sensor, val, &data);
537 iio_device_release_direct_mode(iio_dev);
543 st_lsm6dsx_shub_sampling_freq_avail(struct device *dev,
544 struct device_attribute *attr,
547 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
548 const struct st_lsm6dsx_ext_dev_settings *settings;
551 settings = sensor->ext_info.settings;
552 for (i = 0; i < settings->odr_table.odr_len; i++) {
553 u32 val = settings->odr_table.odr_avl[i].milli_hz;
555 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%03d ",
556 val / 1000, val % 1000);
563 static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev,
564 struct device_attribute *attr,
567 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
568 const struct st_lsm6dsx_ext_dev_settings *settings;
571 settings = sensor->ext_info.settings;
572 for (i = 0; i < settings->fs_table.fs_len; i++)
573 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
574 settings->fs_table.fs_avl[i].gain);
580 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_shub_sampling_freq_avail);
581 static IIO_DEVICE_ATTR(in_scale_available, 0444,
582 st_lsm6dsx_shub_scale_avail, NULL, 0);
583 static struct attribute *st_lsm6dsx_ext_attributes[] = {
584 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
585 &iio_dev_attr_in_scale_available.dev_attr.attr,
589 static const struct attribute_group st_lsm6dsx_ext_attribute_group = {
590 .attrs = st_lsm6dsx_ext_attributes,
593 static const struct iio_info st_lsm6dsx_ext_info = {
594 .attrs = &st_lsm6dsx_ext_attribute_group,
595 .read_raw = st_lsm6dsx_shub_read_raw,
596 .write_raw = st_lsm6dsx_shub_write_raw,
597 .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
600 static struct iio_dev *
601 st_lsm6dsx_shub_alloc_iiodev(struct st_lsm6dsx_hw *hw,
602 enum st_lsm6dsx_sensor_id id,
603 const struct st_lsm6dsx_ext_dev_settings *info,
604 u8 i2c_addr, const char *name)
606 struct iio_chan_spec *ext_channels;
607 struct st_lsm6dsx_sensor *sensor;
608 struct iio_dev *iio_dev;
610 iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor));
614 iio_dev->modes = INDIO_DIRECT_MODE;
615 iio_dev->dev.parent = hw->dev;
616 iio_dev->info = &st_lsm6dsx_ext_info;
618 sensor = iio_priv(iio_dev);
621 sensor->odr = info->odr_table.odr_avl[0].milli_hz;
622 sensor->gain = info->fs_table.fs_avl[0].gain;
623 sensor->ext_info.settings = info;
624 sensor->ext_info.addr = i2c_addr;
625 sensor->watermark = 1;
628 case ST_LSM6DSX_ID_MAGN: {
629 const struct iio_chan_spec magn_channels[] = {
630 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr,
632 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 2,
634 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 4,
636 IIO_CHAN_SOFT_TIMESTAMP(3),
639 ext_channels = devm_kzalloc(hw->dev, sizeof(magn_channels),
644 memcpy(ext_channels, magn_channels, sizeof(magn_channels));
645 iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks;
646 iio_dev->channels = ext_channels;
647 iio_dev->num_channels = ARRAY_SIZE(magn_channels);
649 scnprintf(sensor->name, sizeof(sensor->name), "%s_magn",
656 iio_dev->name = sensor->name;
661 static int st_lsm6dsx_shub_init_device(struct st_lsm6dsx_sensor *sensor)
663 const struct st_lsm6dsx_ext_dev_settings *settings;
666 settings = sensor->ext_info.settings;
667 if (settings->bdu.addr) {
668 err = st_lsm6dsx_shub_write_with_mask(sensor,
670 settings->bdu.mask, 1);
675 if (settings->temp_comp.addr) {
676 err = st_lsm6dsx_shub_write_with_mask(sensor,
677 settings->temp_comp.addr,
678 settings->temp_comp.mask, 1);
683 if (settings->off_canc.addr) {
684 err = st_lsm6dsx_shub_write_with_mask(sensor,
685 settings->off_canc.addr,
686 settings->off_canc.mask, 1);
695 st_lsm6dsx_shub_check_wai(struct st_lsm6dsx_hw *hw, u8 *i2c_addr,
696 const struct st_lsm6dsx_ext_dev_settings *settings)
698 const struct st_lsm6dsx_shub_settings *hub_settings;
699 struct st_lsm6dsx_sensor *sensor;
700 u8 config[3], data, slv_addr;
704 hub_settings = &hw->settings->shub_settings;
705 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
706 sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
708 for (i = 0; i < ARRAY_SIZE(settings->i2c_addr); i++) {
709 if (!settings->i2c_addr[i])
712 /* read wai slave register */
713 config[0] = (settings->i2c_addr[i] << 1) | 0x1;
714 config[1] = settings->wai.addr;
717 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
722 err = st_lsm6dsx_shub_master_enable(sensor, true);
726 st_lsm6dsx_shub_wait_complete(hw);
728 err = st_lsm6dsx_shub_read_reg(hw, &data, sizeof(data));
730 st_lsm6dsx_shub_master_enable(sensor, false);
735 if (data != settings->wai.val)
738 *i2c_addr = settings->i2c_addr[i];
743 /* reset SLV0 channel */
744 memset(config, 0, sizeof(config));
745 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
750 return found ? 0 : -ENODEV;
753 int st_lsm6dsx_shub_probe(struct st_lsm6dsx_hw *hw, const char *name)
755 enum st_lsm6dsx_sensor_id id = ST_LSM6DSX_ID_EXT0;
756 struct st_lsm6dsx_sensor *sensor;
757 int err, i, num_ext_dev = 0;
760 for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_ext_dev_table); i++) {
761 err = st_lsm6dsx_shub_check_wai(hw, &i2c_addr,
762 &st_lsm6dsx_ext_dev_table[i]);
768 hw->iio_devs[id] = st_lsm6dsx_shub_alloc_iiodev(hw, id,
769 &st_lsm6dsx_ext_dev_table[i],
771 if (!hw->iio_devs[id])
774 sensor = iio_priv(hw->iio_devs[id]);
775 err = st_lsm6dsx_shub_init_device(sensor);
779 if (++num_ext_dev >= hw->settings->shub_settings.num_ext_dev)