drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c

   1 /*
   2  * STMicroelectronics st_lsm6dsx i2c controller driver
   3  *
   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
   8  * the hw FIFO
   9  *
  10  * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
  11  *
  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.
  15  *
  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.
  23  *
  24  */
  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>
  30
  31 #include "st_lsm6dsx.h"
  32
  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)
  36
  37 #define ST_LS6DSX_READ_OP_MASK                  GENMASK(2, 0)
  38
  39 static const struct st_lsm6dsx_ext_dev_settings st_lsm6dsx_ext_dev_table[] = {
  40         /* LIS2MDL */
  41         {
  42                 .i2c_addr = { 0x1e },
  43                 .wai = {
  44                         .addr = 0x4f,
  45                         .val = 0x40,
  46                 },
  47                 .id = ST_LSM6DSX_ID_MAGN,
  48                 .odr_table = {
  49                         .reg = {
  50                                 .addr = 0x60,
  51                                 .mask = GENMASK(3, 2),
  52                         },
  53                         .odr_avl[0] = {  10000, 0x0 },
  54                         .odr_avl[1] = {  20000, 0x1 },
  55                         .odr_avl[2] = {  50000, 0x2 },
  56                         .odr_avl[3] = { 100000, 0x3 },
  57                         .odr_len = 4,
  58                 },
  59                 .fs_table = {
  60                         .fs_avl[0] = {
  61                                 .gain = 1500,
  62                                 .val = 0x0,
  63                         }, /* 1500 uG/LSB */
  64                         .fs_len = 1,
  65                 },
  66                 .temp_comp = {
  67                         .addr = 0x60,
  68                         .mask = BIT(7),
  69                 },
  70                 .pwr_table = {
  71                         .reg = {
  72                                 .addr = 0x60,
  73                                 .mask = GENMASK(1, 0),
  74                         },
  75                         .off_val = 0x2,
  76                         .on_val = 0x0,
  77                 },
  78                 .off_canc = {
  79                         .addr = 0x61,
  80                         .mask = BIT(1),
  81                 },
  82                 .bdu = {
  83                         .addr = 0x62,
  84                         .mask = BIT(4),
  85                 },
  86                 .out = {
  87                         .addr = 0x68,
  88                         .len = 6,
  89                 },
  90         },
  91         /* LIS3MDL */
  92         {
  93                 .i2c_addr = { 0x1e },
  94                 .wai = {
  95                         .addr = 0x0f,
  96                         .val = 0x3d,
  97                 },
  98                 .id = ST_LSM6DSX_ID_MAGN,
  99                 .odr_table = {
 100                         .reg = {
 101                                 .addr = 0x20,
 102                                 .mask = GENMASK(4, 2),
 103                         },
 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 },
 112                         .odr_len = 8,
 113                 },
 114                 .fs_table = {
 115                         .reg = {
 116                                 .addr = 0x21,
 117                                 .mask = GENMASK(6, 5),
 118                         },
 119                         .fs_avl[0] = {
 120                                 .gain = 146,
 121                                 .val = 0x00,
 122                         }, /* 4000 uG/LSB */
 123                         .fs_avl[1] = {
 124                                 .gain = 292,
 125                                 .val = 0x01,
 126                         }, /* 8000 uG/LSB */
 127                         .fs_avl[2] = {
 128                                 .gain = 438,
 129                                 .val = 0x02,
 130                         }, /* 12000 uG/LSB */
 131                         .fs_avl[3] = {
 132                                 .gain = 584,
 133                                 .val = 0x03,
 134                         }, /* 16000 uG/LSB */
 135                         .fs_len = 4,
 136                 },
 137                 .pwr_table = {
 138                         .reg = {
 139                                 .addr = 0x22,
 140                                 .mask = GENMASK(1, 0),
 141                         },
 142                         .off_val = 0x2,
 143                         .on_val = 0x0,
 144                 },
 145                 .bdu = {
 146                         .addr = 0x24,
 147                         .mask = BIT(6),
 148                 },
 149                 .out = {
 150                         .addr = 0x28,
 151                         .len = 6,
 152                 },
 153         },
 154 };
 155
 156 static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)
 157 {
 158         struct st_lsm6dsx_sensor *sensor;
 159         u32 odr, timeout;
 160
 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);
 165         msleep(timeout);
 166 }
 167
 168 /*
 169  * st_lsm6dsx_shub_read_output - read i2c controller register
 170  *
 171  * Read st_lsm6dsx i2c controller register
 172  */
 173 static int
 174 st_lsm6dsx_shub_read_output(struct st_lsm6dsx_hw *hw, u8 *data,
 175                             int len)
 176 {
 177         const struct st_lsm6dsx_shub_settings *hub_settings;
 178         int err;
 179
 180         mutex_lock(&hw->page_lock);
 181
 182         hub_settings = &hw->settings->shub_settings;
 183         if (hub_settings->shub_out.sec_page) {
 184                 err = st_lsm6dsx_set_page(hw, true);
 185                 if (err < 0)
 186                         goto out;
 187         }
 188
 189         err = regmap_bulk_read(hw->regmap, hub_settings->shub_out.addr,
 190                                data, len);
 191
 192         if (hub_settings->shub_out.sec_page)
 193                 st_lsm6dsx_set_page(hw, false);
 194 out:
 195         mutex_unlock(&hw->page_lock);
 196
 197         return err;
 198 }
 199
 200 /*
 201  * st_lsm6dsx_shub_write_reg - write i2c controller register
 202  *
 203  * Write st_lsm6dsx i2c controller register
 204  */
 205 static int st_lsm6dsx_shub_write_reg(struct st_lsm6dsx_hw *hw, u8 addr,
 206                                      u8 *data, int len)
 207 {
 208         int err;
 209
 210         mutex_lock(&hw->page_lock);
 211         err = st_lsm6dsx_set_page(hw, true);
 212         if (err < 0)
 213                 goto out;
 214
 215         err = regmap_bulk_write(hw->regmap, addr, data, len);
 216
 217         st_lsm6dsx_set_page(hw, false);
 218 out:
 219         mutex_unlock(&hw->page_lock);
 220
 221         return err;
 222 }
 223
 224 static int
 225 st_lsm6dsx_shub_write_reg_with_mask(struct st_lsm6dsx_hw *hw, u8 addr,
 226                                     u8 mask, u8 val)
 227 {
 228         int err;
 229
 230         mutex_lock(&hw->page_lock);
 231         err = st_lsm6dsx_set_page(hw, true);
 232         if (err < 0)
 233                 goto out;
 234
 235         err = regmap_update_bits(hw->regmap, addr, mask, val);
 236
 237         st_lsm6dsx_set_page(hw, false);
 238 out:
 239         mutex_unlock(&hw->page_lock);
 240
 241         return err;
 242 }
 243
 244 static int st_lsm6dsx_shub_master_enable(struct st_lsm6dsx_sensor *sensor,
 245                                          bool enable)
 246 {
 247         const struct st_lsm6dsx_shub_settings *hub_settings;
 248         struct st_lsm6dsx_hw *hw = sensor->hw;
 249         unsigned int data;
 250         int err;
 251
 252         /* enable acc sensor as trigger */
 253         err = st_lsm6dsx_sensor_set_enable(sensor, enable);
 254         if (err < 0)
 255                 return err;
 256
 257         mutex_lock(&hw->page_lock);
 258
 259         hub_settings = &hw->settings->shub_settings;
 260         if (hub_settings->master_en.sec_page) {
 261                 err = st_lsm6dsx_set_page(hw, true);
 262                 if (err < 0)
 263                         goto out;
 264         }
 265
 266         data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->master_en.mask);
 267         err = regmap_update_bits(hw->regmap, hub_settings->master_en.addr,
 268                                  hub_settings->master_en.mask, data);
 269
 270         if (hub_settings->master_en.sec_page)
 271                 st_lsm6dsx_set_page(hw, false);
 272 out:
 273         mutex_unlock(&hw->page_lock);
 274
 275         return err;
 276 }
 277
 278 /*
 279  * st_lsm6dsx_shub_read - read data from slave device register
 280  *
 281  * Read data from slave device register. SLV0 is used for
 282  * one-shot read operation
 283  */
 284 static int
 285 st_lsm6dsx_shub_read(struct st_lsm6dsx_sensor *sensor, u8 addr,
 286                      u8 *data, int len)
 287 {
 288         const struct st_lsm6dsx_shub_settings *hub_settings;
 289         u8 config[3], slv_addr, slv_config = 0;
 290         struct st_lsm6dsx_hw *hw = sensor->hw;
 291         const struct st_lsm6dsx_reg *aux_sens;
 292         int err;
 293
 294         hub_settings = &hw->settings->shub_settings;
 295         slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
 296         aux_sens = &hw->settings->shub_settings.aux_sens;
 297         /* do not overwrite aux_sens */
 298         if (slv_addr + 2 == aux_sens->addr)
 299                 slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
 300
 301         config[0] = (sensor->ext_info.addr << 1) | 1;
 302         config[1] = addr;
 303         config[2] = (len & ST_LS6DSX_READ_OP_MASK) | slv_config;
 304
 305         err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 306                                         sizeof(config));
 307         if (err < 0)
 308                 return err;
 309
 310         err = st_lsm6dsx_shub_master_enable(sensor, true);
 311         if (err < 0)
 312                 return err;
 313
 314         st_lsm6dsx_shub_wait_complete(hw);
 315
 316         err = st_lsm6dsx_shub_read_output(hw, data,
 317                                           len & ST_LS6DSX_READ_OP_MASK);
 318         if (err < 0)
 319                 return err;
 320
 321         st_lsm6dsx_shub_master_enable(sensor, false);
 322
 323         config[0] = hub_settings->pause;
 324         config[1] = 0;
 325         config[2] = slv_config;
 326         return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 327                                          sizeof(config));
 328 }
 329
 330 /*
 331  * st_lsm6dsx_shub_write - write data to slave device register
 332  *
 333  * Write data from slave device register. SLV0 is used for
 334  * one-shot write operation
 335  */
 336 static int
 337 st_lsm6dsx_shub_write(struct st_lsm6dsx_sensor *sensor, u8 addr,
 338                       u8 *data, int len)
 339 {
 340         const struct st_lsm6dsx_shub_settings *hub_settings;
 341         struct st_lsm6dsx_hw *hw = sensor->hw;
 342         u8 config[2], slv_addr;
 343         int err, i;
 344
 345         hub_settings = &hw->settings->shub_settings;
 346         if (hub_settings->wr_once.addr) {
 347                 unsigned int data;
 348
 349                 data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->wr_once.mask);
 350                 err = st_lsm6dsx_shub_write_reg_with_mask(hw,
 351                         hub_settings->wr_once.addr,
 352                         hub_settings->wr_once.mask,
 353                         data);
 354                 if (err < 0)
 355                         return err;
 356         }
 357
 358         slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
 359         config[0] = sensor->ext_info.addr << 1;
 360         for (i = 0 ; i < len; i++) {
 361                 config[1] = addr + i;
 362
 363                 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 364                                                 sizeof(config));
 365                 if (err < 0)
 366                         return err;
 367
 368                 err = st_lsm6dsx_shub_write_reg(hw, hub_settings->dw_slv0_addr,
 369                                                 &data[i], 1);
 370                 if (err < 0)
 371                         return err;
 372
 373                 err = st_lsm6dsx_shub_master_enable(sensor, true);
 374                 if (err < 0)
 375                         return err;
 376
 377                 st_lsm6dsx_shub_wait_complete(hw);
 378
 379                 st_lsm6dsx_shub_master_enable(sensor, false);
 380         }
 381
 382         config[0] = hub_settings->pause;
 383         config[1] = 0;
 384         return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, sizeof(config));
 385 }
 386
 387 static int
 388 st_lsm6dsx_shub_write_with_mask(struct st_lsm6dsx_sensor *sensor,
 389                                 u8 addr, u8 mask, u8 val)
 390 {
 391         int err;
 392         u8 data;
 393
 394         err = st_lsm6dsx_shub_read(sensor, addr, &data, sizeof(data));
 395         if (err < 0)
 396                 return err;
 397
 398         data = ((data & ~mask) | (val << __ffs(mask) & mask));
 399
 400         return st_lsm6dsx_shub_write(sensor, addr, &data, sizeof(data));
 401 }
 402
 403 static int
 404 st_lsm6dsx_shub_get_odr_val(struct st_lsm6dsx_sensor *sensor,
 405                             u32 odr, u16 *val)
 406 {
 407         const struct st_lsm6dsx_ext_dev_settings *settings;
 408         int i;
 409
 410         settings = sensor->ext_info.settings;
 411         for (i = 0; i < settings->odr_table.odr_len; i++) {
 412                 if (settings->odr_table.odr_avl[i].milli_hz == odr)
 413                         break;
 414         }
 415
 416         if (i == settings->odr_table.odr_len)
 417                 return -EINVAL;
 418
 419         *val = settings->odr_table.odr_avl[i].val;
 420         return 0;
 421 }
 422
 423 static int
 424 st_lsm6dsx_shub_set_odr(struct st_lsm6dsx_sensor *sensor, u32 odr)
 425 {
 426         const struct st_lsm6dsx_ext_dev_settings *settings;
 427         u16 val;
 428         int err;
 429
 430         err = st_lsm6dsx_shub_get_odr_val(sensor, odr, &val);
 431         if (err < 0)
 432                 return err;
 433
 434         settings = sensor->ext_info.settings;
 435         return st_lsm6dsx_shub_write_with_mask(sensor,
 436                                                settings->odr_table.reg.addr,
 437                                                settings->odr_table.reg.mask,
 438                                                val);
 439 }
 440
 441 /* use SLV{1,2,3} for FIFO read operations */
 442 static int
 443 st_lsm6dsx_shub_config_channels(struct st_lsm6dsx_sensor *sensor,
 444                                 bool enable)
 445 {
 446         const struct st_lsm6dsx_shub_settings *hub_settings;
 447         const struct st_lsm6dsx_ext_dev_settings *settings;
 448         u8 config[9] = {}, enable_mask, slv_addr;
 449         struct st_lsm6dsx_hw *hw = sensor->hw;
 450         struct st_lsm6dsx_sensor *cur_sensor;
 451         int i, j = 0;
 452
 453         hub_settings = &hw->settings->shub_settings;
 454         if (enable)
 455                 enable_mask = hw->enable_mask | BIT(sensor->id);
 456         else
 457                 enable_mask = hw->enable_mask & ~BIT(sensor->id);
 458
 459         for (i = ST_LSM6DSX_ID_EXT0; i <= ST_LSM6DSX_ID_EXT2; i++) {
 460                 if (!hw->iio_devs[i])
 461                         continue;
 462
 463                 cur_sensor = iio_priv(hw->iio_devs[i]);
 464                 if (!(enable_mask & BIT(cur_sensor->id)))
 465                         continue;
 466
 467                 settings = cur_sensor->ext_info.settings;
 468                 config[j] = (sensor->ext_info.addr << 1) | 1;
 469                 config[j + 1] = settings->out.addr;
 470                 config[j + 2] = (settings->out.len & ST_LS6DSX_READ_OP_MASK) |
 471                                 hub_settings->batch_en;
 472                 j += 3;
 473         }
 474
 475         slv_addr = ST_LSM6DSX_SLV_ADDR(1, hub_settings->slv0_addr);
 476         return st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 477                                          sizeof(config));
 478 }
 479
 480 int st_lsm6dsx_shub_set_enable(struct st_lsm6dsx_sensor *sensor, bool enable)
 481 {
 482         const struct st_lsm6dsx_ext_dev_settings *settings;
 483         int err;
 484
 485         err = st_lsm6dsx_shub_config_channels(sensor, enable);
 486         if (err < 0)
 487                 return err;
 488
 489         settings = sensor->ext_info.settings;
 490         if (enable) {
 491                 err = st_lsm6dsx_shub_set_odr(sensor,
 492                                               sensor->ext_info.slv_odr);
 493                 if (err < 0)
 494                         return err;
 495         } else {
 496                 err = st_lsm6dsx_shub_write_with_mask(sensor,
 497                                         settings->odr_table.reg.addr,
 498                                         settings->odr_table.reg.mask, 0);
 499                 if (err < 0)
 500                         return err;
 501         }
 502
 503         if (settings->pwr_table.reg.addr) {
 504                 u8 val;
 505
 506                 val = enable ? settings->pwr_table.on_val
 507                              : settings->pwr_table.off_val;
 508                 err = st_lsm6dsx_shub_write_with_mask(sensor,
 509                                         settings->pwr_table.reg.addr,
 510                                         settings->pwr_table.reg.mask, val);
 511                 if (err < 0)
 512                         return err;
 513         }
 514
 515         return st_lsm6dsx_shub_master_enable(sensor, enable);
 516 }
 517
 518 static int
 519 st_lsm6dsx_shub_read_oneshot(struct st_lsm6dsx_sensor *sensor,
 520                              struct iio_chan_spec const *ch,
 521                              int *val)
 522 {
 523         int err, delay, len;
 524         u8 data[4];
 525
 526         err = st_lsm6dsx_shub_set_enable(sensor, true);
 527         if (err < 0)
 528                 return err;
 529
 530         delay = 1000000000 / sensor->ext_info.slv_odr;
 531         usleep_range(delay, 2 * delay);
 532
 533         len = min_t(int, sizeof(data), ch->scan_type.realbits >> 3);
 534         err = st_lsm6dsx_shub_read(sensor, ch->address, data, len);
 535         if (err < 0)
 536                 return err;
 537
 538         err = st_lsm6dsx_shub_set_enable(sensor, false);
 539         if (err < 0)
 540                 return err;
 541
 542         switch (len) {
 543         case 2:
 544                 *val = (s16)le16_to_cpu(*((__le16 *)data));
 545                 break;
 546         default:
 547                 return -EINVAL;
 548         }
 549
 550         return IIO_VAL_INT;
 551 }
 552
 553 static int
 554 st_lsm6dsx_shub_read_raw(struct iio_dev *iio_dev,
 555                          struct iio_chan_spec const *ch,
 556                          int *val, int *val2, long mask)
 557 {
 558         struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
 559         int ret;
 560
 561         switch (mask) {
 562         case IIO_CHAN_INFO_RAW:
 563                 ret = iio_device_claim_direct_mode(iio_dev);
 564                 if (ret)
 565                         break;
 566
 567                 ret = st_lsm6dsx_shub_read_oneshot(sensor, ch, val);
 568                 iio_device_release_direct_mode(iio_dev);
 569                 break;
 570         case IIO_CHAN_INFO_SAMP_FREQ:
 571                 *val = sensor->ext_info.slv_odr / 1000;
 572                 *val2 = (sensor->ext_info.slv_odr % 1000) * 1000;
 573                 ret = IIO_VAL_INT_PLUS_MICRO;
 574                 break;
 575         case IIO_CHAN_INFO_SCALE:
 576                 *val = 0;
 577                 *val2 = sensor->gain;
 578                 ret = IIO_VAL_INT_PLUS_MICRO;
 579                 break;
 580         default:
 581                 ret = -EINVAL;
 582                 break;
 583         }
 584
 585         return ret;
 586 }
 587
 588 static int
 589 st_lsm6dsx_shub_set_full_scale(struct st_lsm6dsx_sensor *sensor,
 590                                u32 gain)
 591 {
 592         const struct st_lsm6dsx_fs_table_entry *fs_table;
 593         int i, err;
 594
 595         fs_table = &sensor->ext_info.settings->fs_table;
 596         if (!fs_table->reg.addr)
 597                 return -ENOTSUPP;
 598
 599         for (i = 0; i < fs_table->fs_len; i++) {
 600                 if (fs_table->fs_avl[i].gain == gain)
 601                         break;
 602         }
 603
 604         if (i == fs_table->fs_len)
 605                 return -EINVAL;
 606
 607         err = st_lsm6dsx_shub_write_with_mask(sensor, fs_table->reg.addr,
 608                                               fs_table->reg.mask,
 609                                               fs_table->fs_avl[i].val);
 610         if (err < 0)
 611                 return err;
 612
 613         sensor->gain = gain;
 614
 615         return 0;
 616 }
 617
 618 static int
 619 st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev,
 620                           struct iio_chan_spec const *chan,
 621                           int val, int val2, long mask)
 622 {
 623         struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
 624         int err;
 625
 626         err = iio_device_claim_direct_mode(iio_dev);
 627         if (err)
 628                 return err;
 629
 630         switch (mask) {
 631         case IIO_CHAN_INFO_SAMP_FREQ: {
 632                 u16 data;
 633
 634                 val = val * 1000 + val2 / 1000;
 635                 err = st_lsm6dsx_shub_get_odr_val(sensor, val, &data);
 636                 if (!err) {
 637                         struct st_lsm6dsx_hw *hw = sensor->hw;
 638                         struct st_lsm6dsx_sensor *ref_sensor;
 639                         u8 odr_val;
 640                         int odr;
 641
 642                         ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
 643                         odr = st_lsm6dsx_check_odr(ref_sensor, val, &odr_val);
 644                         if (odr < 0) {
 645                                 err = odr;
 646                                 goto release;
 647                         }
 648
 649                         sensor->ext_info.slv_odr = val;
 650                         sensor->odr = odr;
 651                 }
 652                 break;
 653         }
 654         case IIO_CHAN_INFO_SCALE:
 655                 err = st_lsm6dsx_shub_set_full_scale(sensor, val2);
 656                 break;
 657         default:
 658                 err = -EINVAL;
 659                 break;
 660         }
 661
 662 release:
 663         iio_device_release_direct_mode(iio_dev);
 664
 665         return err;
 666 }
 667
 668 static ssize_t
 669 st_lsm6dsx_shub_sampling_freq_avail(struct device *dev,
 670                                     struct device_attribute *attr,
 671                                     char *buf)
 672 {
 673         struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
 674         const struct st_lsm6dsx_ext_dev_settings *settings;
 675         int i, len = 0;
 676
 677         settings = sensor->ext_info.settings;
 678         for (i = 0; i < settings->odr_table.odr_len; i++) {
 679                 u32 val = settings->odr_table.odr_avl[i].milli_hz;
 680
 681                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%03d ",
 682                                  val / 1000, val % 1000);
 683         }
 684         buf[len - 1] = '\n';
 685
 686         return len;
 687 }
 688
 689 static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev,
 690                                            struct device_attribute *attr,
 691                                            char *buf)
 692 {
 693         struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
 694         const struct st_lsm6dsx_ext_dev_settings *settings;
 695         int i, len = 0;
 696
 697         settings = sensor->ext_info.settings;
 698         for (i = 0; i < settings->fs_table.fs_len; i++)
 699                 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
 700                                  settings->fs_table.fs_avl[i].gain);
 701         buf[len - 1] = '\n';
 702
 703         return len;
 704 }
 705
 706 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_shub_sampling_freq_avail);
 707 static IIO_DEVICE_ATTR(in_scale_available, 0444,
 708                        st_lsm6dsx_shub_scale_avail, NULL, 0);
 709 static struct attribute *st_lsm6dsx_ext_attributes[] = {
 710         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 711         &iio_dev_attr_in_scale_available.dev_attr.attr,
 712         NULL,
 713 };
 714
 715 static const struct attribute_group st_lsm6dsx_ext_attribute_group = {
 716         .attrs = st_lsm6dsx_ext_attributes,
 717 };
 718
 719 static const struct iio_info st_lsm6dsx_ext_info = {
 720         .attrs = &st_lsm6dsx_ext_attribute_group,
 721         .read_raw = st_lsm6dsx_shub_read_raw,
 722         .write_raw = st_lsm6dsx_shub_write_raw,
 723         .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
 724 };
 725
 726 static struct iio_dev *
 727 st_lsm6dsx_shub_alloc_iiodev(struct st_lsm6dsx_hw *hw,
 728                              enum st_lsm6dsx_sensor_id id,
 729                              const struct st_lsm6dsx_ext_dev_settings *info,
 730                              u8 i2c_addr, const char *name)
 731 {
 732         enum st_lsm6dsx_sensor_id ref_id = ST_LSM6DSX_ID_ACC;
 733         struct iio_chan_spec *ext_channels;
 734         struct st_lsm6dsx_sensor *sensor;
 735         struct iio_dev *iio_dev;
 736
 737         iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor));
 738         if (!iio_dev)
 739                 return NULL;
 740
 741         iio_dev->modes = INDIO_DIRECT_MODE;
 742         iio_dev->info = &st_lsm6dsx_ext_info;
 743
 744         sensor = iio_priv(iio_dev);
 745         sensor->id = id;
 746         sensor->hw = hw;
 747         sensor->odr = hw->settings->odr_table[ref_id].odr_avl[0].milli_hz;
 748         sensor->ext_info.slv_odr = info->odr_table.odr_avl[0].milli_hz;
 749         sensor->gain = info->fs_table.fs_avl[0].gain;
 750         sensor->ext_info.settings = info;
 751         sensor->ext_info.addr = i2c_addr;
 752         sensor->watermark = 1;
 753
 754         switch (info->id) {
 755         case ST_LSM6DSX_ID_MAGN: {
 756                 const struct iio_chan_spec magn_channels[] = {
 757                         ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr,
 758                                            IIO_MOD_X, 0),
 759                         ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 2,
 760                                            IIO_MOD_Y, 1),
 761                         ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 4,
 762                                            IIO_MOD_Z, 2),
 763                         IIO_CHAN_SOFT_TIMESTAMP(3),
 764                 };
 765
 766                 ext_channels = devm_kzalloc(hw->dev, sizeof(magn_channels),
 767                                             GFP_KERNEL);
 768                 if (!ext_channels)
 769                         return NULL;
 770
 771                 memcpy(ext_channels, magn_channels, sizeof(magn_channels));
 772                 iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks;
 773                 iio_dev->channels = ext_channels;
 774                 iio_dev->num_channels = ARRAY_SIZE(magn_channels);
 775
 776                 scnprintf(sensor->name, sizeof(sensor->name), "%s_magn",
 777                           name);
 778                 break;
 779         }
 780         default:
 781                 return NULL;
 782         }
 783         iio_dev->name = sensor->name;
 784
 785         return iio_dev;
 786 }
 787
 788 static int st_lsm6dsx_shub_init_device(struct st_lsm6dsx_sensor *sensor)
 789 {
 790         const struct st_lsm6dsx_ext_dev_settings *settings;
 791         int err;
 792
 793         settings = sensor->ext_info.settings;
 794         if (settings->bdu.addr) {
 795                 err = st_lsm6dsx_shub_write_with_mask(sensor,
 796                                                       settings->bdu.addr,
 797                                                       settings->bdu.mask, 1);
 798                 if (err < 0)
 799                         return err;
 800         }
 801
 802         if (settings->temp_comp.addr) {
 803                 err = st_lsm6dsx_shub_write_with_mask(sensor,
 804                                         settings->temp_comp.addr,
 805                                         settings->temp_comp.mask, 1);
 806                 if (err < 0)
 807                         return err;
 808         }
 809
 810         if (settings->off_canc.addr) {
 811                 err = st_lsm6dsx_shub_write_with_mask(sensor,
 812                                         settings->off_canc.addr,
 813                                         settings->off_canc.mask, 1);
 814                 if (err < 0)
 815                         return err;
 816         }
 817
 818         return 0;
 819 }
 820
 821 static int
 822 st_lsm6dsx_shub_check_wai(struct st_lsm6dsx_hw *hw, u8 *i2c_addr,
 823                           const struct st_lsm6dsx_ext_dev_settings *settings)
 824 {
 825         const struct st_lsm6dsx_shub_settings *hub_settings;
 826         u8 config[3], data, slv_addr, slv_config = 0;
 827         const struct st_lsm6dsx_reg *aux_sens;
 828         struct st_lsm6dsx_sensor *sensor;
 829         bool found = false;
 830         int i, err;
 831
 832         sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
 833         hub_settings = &hw->settings->shub_settings;
 834         aux_sens = &hw->settings->shub_settings.aux_sens;
 835         slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr);
 836         /* do not overwrite aux_sens */
 837         if (slv_addr + 2 == aux_sens->addr)
 838                 slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask);
 839
 840         for (i = 0; i < ARRAY_SIZE(settings->i2c_addr); i++) {
 841                 if (!settings->i2c_addr[i])
 842                         continue;
 843
 844                 /* read wai slave register */
 845                 config[0] = (settings->i2c_addr[i] << 1) | 0x1;
 846                 config[1] = settings->wai.addr;
 847                 config[2] = 0x1 | slv_config;
 848
 849                 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 850                                                 sizeof(config));
 851                 if (err < 0)
 852                         return err;
 853
 854                 err = st_lsm6dsx_shub_master_enable(sensor, true);
 855                 if (err < 0)
 856                         return err;
 857
 858                 st_lsm6dsx_shub_wait_complete(hw);
 859
 860                 err = st_lsm6dsx_shub_read_output(hw, &data, sizeof(data));
 861
 862                 st_lsm6dsx_shub_master_enable(sensor, false);
 863
 864                 if (err < 0)
 865                         return err;
 866
 867                 if (data != settings->wai.val)
 868                         continue;
 869
 870                 *i2c_addr = settings->i2c_addr[i];
 871                 found = true;
 872                 break;
 873         }
 874
 875         /* reset SLV0 channel */
 876         config[0] = hub_settings->pause;
 877         config[1] = 0;
 878         config[2] = slv_config;
 879         err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config,
 880                                         sizeof(config));
 881         if (err < 0)
 882                 return err;
 883
 884         return found ? 0 : -ENODEV;
 885 }
 886
 887 int st_lsm6dsx_shub_probe(struct st_lsm6dsx_hw *hw, const char *name)
 888 {
 889         enum st_lsm6dsx_sensor_id id = ST_LSM6DSX_ID_EXT0;
 890         struct st_lsm6dsx_sensor *sensor;
 891         int err, i, num_ext_dev = 0;
 892         u8 i2c_addr = 0;
 893
 894         for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_ext_dev_table); i++) {
 895                 err = st_lsm6dsx_shub_check_wai(hw, &i2c_addr,
 896                                         &st_lsm6dsx_ext_dev_table[i]);
 897                 if (err == -ENODEV)
 898                         continue;
 899                 else if (err < 0)
 900                         return err;
 901
 902                 hw->iio_devs[id] = st_lsm6dsx_shub_alloc_iiodev(hw, id,
 903                                                 &st_lsm6dsx_ext_dev_table[i],
 904                                                 i2c_addr, name);
 905                 if (!hw->iio_devs[id])
 906                         return -ENOMEM;
 907
 908                 sensor = iio_priv(hw->iio_devs[id]);
 909                 err = st_lsm6dsx_shub_init_device(sensor);
 910                 if (err < 0)
 911                         return err;
 912
 913                 if (++num_ext_dev >= hw->settings->shub_settings.num_ext_dev)
 914                         break;
 915                 id++;
 916         }
 917
 918         return 0;
 919 }