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 int st_lsm6dsx_shub_read_output(struct st_lsm6dsx_hw *hw, u8 *data, int len) 174 { 175 const struct st_lsm6dsx_shub_settings *hub_settings; 176 int err; 177 178 mutex_lock(&hw->page_lock); 179 180 hub_settings = &hw->settings->shub_settings; 181 if (hub_settings->shub_out.sec_page) { 182 err = st_lsm6dsx_set_page(hw, true); 183 if (err < 0) 184 goto out; 185 } 186 187 err = regmap_bulk_read(hw->regmap, hub_settings->shub_out.addr, 188 data, len); 189 190 if (hub_settings->shub_out.sec_page) 191 st_lsm6dsx_set_page(hw, false); 192 out: 193 mutex_unlock(&hw->page_lock); 194 195 return err; 196 } 197 198 /* 199 * st_lsm6dsx_shub_write_reg - write i2c controller register 200 * 201 * Write st_lsm6dsx i2c controller register 202 */ 203 static int st_lsm6dsx_shub_write_reg(struct st_lsm6dsx_hw *hw, u8 addr, 204 u8 *data, int len) 205 { 206 int err; 207 208 mutex_lock(&hw->page_lock); 209 err = st_lsm6dsx_set_page(hw, true); 210 if (err < 0) 211 goto out; 212 213 err = regmap_bulk_write(hw->regmap, addr, data, len); 214 215 st_lsm6dsx_set_page(hw, false); 216 out: 217 mutex_unlock(&hw->page_lock); 218 219 return err; 220 } 221 222 static int 223 st_lsm6dsx_shub_write_reg_with_mask(struct st_lsm6dsx_hw *hw, u8 addr, 224 u8 mask, u8 val) 225 { 226 int err; 227 228 mutex_lock(&hw->page_lock); 229 err = st_lsm6dsx_set_page(hw, true); 230 if (err < 0) 231 goto out; 232 233 err = regmap_update_bits(hw->regmap, addr, mask, val); 234 235 st_lsm6dsx_set_page(hw, false); 236 out: 237 mutex_unlock(&hw->page_lock); 238 239 return err; 240 } 241 242 static int st_lsm6dsx_shub_master_enable(struct st_lsm6dsx_sensor *sensor, 243 bool enable) 244 { 245 const struct st_lsm6dsx_shub_settings *hub_settings; 246 struct st_lsm6dsx_hw *hw = sensor->hw; 247 unsigned int data; 248 int err; 249 250 /* enable acc sensor as trigger */ 251 err = st_lsm6dsx_sensor_set_enable(sensor, enable); 252 if (err < 0) 253 return err; 254 255 mutex_lock(&hw->page_lock); 256 257 hub_settings = &hw->settings->shub_settings; 258 if (hub_settings->master_en.sec_page) { 259 err = st_lsm6dsx_set_page(hw, true); 260 if (err < 0) 261 goto out; 262 } 263 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); 267 268 if (hub_settings->master_en.sec_page) 269 st_lsm6dsx_set_page(hw, false); 270 out: 271 mutex_unlock(&hw->page_lock); 272 273 return err; 274 } 275 276 /* 277 * st_lsm6dsx_shub_read - read data from slave device register 278 * 279 * Read data from slave device register. SLV0 is used for 280 * one-shot read operation 281 */ 282 static int 283 st_lsm6dsx_shub_read(struct st_lsm6dsx_sensor *sensor, u8 addr, 284 u8 *data, int len) 285 { 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; 290 int err; 291 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); 298 299 config[0] = (sensor->ext_info.addr << 1) | 1; 300 config[1] = addr; 301 config[2] = (len & ST_LS6DSX_READ_OP_MASK) | slv_config; 302 303 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 304 sizeof(config)); 305 if (err < 0) 306 return err; 307 308 err = st_lsm6dsx_shub_master_enable(sensor, true); 309 if (err < 0) 310 return err; 311 312 st_lsm6dsx_shub_wait_complete(hw); 313 314 err = st_lsm6dsx_shub_read_output(hw, data, 315 len & ST_LS6DSX_READ_OP_MASK); 316 if (err < 0) 317 return err; 318 319 st_lsm6dsx_shub_master_enable(sensor, false); 320 321 config[0] = hub_settings->pause; 322 config[1] = 0; 323 config[2] = slv_config; 324 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 325 sizeof(config)); 326 } 327 328 /* 329 * st_lsm6dsx_shub_write - write data to slave device register 330 * 331 * Write data from slave device register. SLV0 is used for 332 * one-shot write operation 333 */ 334 static int 335 st_lsm6dsx_shub_write(struct st_lsm6dsx_sensor *sensor, u8 addr, 336 u8 *data, int len) 337 { 338 const struct st_lsm6dsx_shub_settings *hub_settings; 339 struct st_lsm6dsx_hw *hw = sensor->hw; 340 u8 config[2], slv_addr; 341 int err, i; 342 343 hub_settings = &hw->settings->shub_settings; 344 if (hub_settings->wr_once.addr) { 345 unsigned int data; 346 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, 351 data); 352 if (err < 0) 353 return err; 354 } 355 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; 360 361 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 362 sizeof(config)); 363 if (err < 0) 364 return err; 365 366 err = st_lsm6dsx_shub_write_reg(hw, hub_settings->dw_slv0_addr, 367 &data[i], 1); 368 if (err < 0) 369 return err; 370 371 err = st_lsm6dsx_shub_master_enable(sensor, true); 372 if (err < 0) 373 return err; 374 375 st_lsm6dsx_shub_wait_complete(hw); 376 377 st_lsm6dsx_shub_master_enable(sensor, false); 378 } 379 380 config[0] = hub_settings->pause; 381 config[1] = 0; 382 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, sizeof(config)); 383 } 384 385 static int 386 st_lsm6dsx_shub_write_with_mask(struct st_lsm6dsx_sensor *sensor, 387 u8 addr, u8 mask, u8 val) 388 { 389 int err; 390 u8 data; 391 392 err = st_lsm6dsx_shub_read(sensor, addr, &data, sizeof(data)); 393 if (err < 0) 394 return err; 395 396 data = ((data & ~mask) | (val << __ffs(mask) & mask)); 397 398 return st_lsm6dsx_shub_write(sensor, addr, &data, sizeof(data)); 399 } 400 401 static int 402 st_lsm6dsx_shub_get_odr_val(struct st_lsm6dsx_sensor *sensor, 403 u32 odr, u16 *val) 404 { 405 const struct st_lsm6dsx_ext_dev_settings *settings; 406 int i; 407 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) 411 break; 412 } 413 414 if (i == settings->odr_table.odr_len) 415 return -EINVAL; 416 417 *val = settings->odr_table.odr_avl[i].val; 418 return 0; 419 } 420 421 static int 422 st_lsm6dsx_shub_set_odr(struct st_lsm6dsx_sensor *sensor, u32 odr) 423 { 424 const struct st_lsm6dsx_ext_dev_settings *settings; 425 u16 val; 426 int err; 427 428 err = st_lsm6dsx_shub_get_odr_val(sensor, odr, &val); 429 if (err < 0) 430 return err; 431 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, 436 val); 437 } 438 439 /* use SLV{1,2,3} for FIFO read operations */ 440 static int 441 st_lsm6dsx_shub_config_channels(struct st_lsm6dsx_sensor *sensor, 442 bool enable) 443 { 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; 449 int i, j = 0; 450 451 hub_settings = &hw->settings->shub_settings; 452 if (enable) 453 enable_mask = hw->enable_mask | BIT(sensor->id); 454 else 455 enable_mask = hw->enable_mask & ~BIT(sensor->id); 456 457 for (i = ST_LSM6DSX_ID_EXT0; i <= ST_LSM6DSX_ID_EXT2; i++) { 458 if (!hw->iio_devs[i]) 459 continue; 460 461 cur_sensor = iio_priv(hw->iio_devs[i]); 462 if (!(enable_mask & BIT(cur_sensor->id))) 463 continue; 464 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; 470 j += 3; 471 } 472 473 slv_addr = ST_LSM6DSX_SLV_ADDR(1, hub_settings->slv0_addr); 474 return st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 475 sizeof(config)); 476 } 477 478 int st_lsm6dsx_shub_set_enable(struct st_lsm6dsx_sensor *sensor, bool enable) 479 { 480 const struct st_lsm6dsx_ext_dev_settings *settings; 481 int err; 482 483 err = st_lsm6dsx_shub_config_channels(sensor, enable); 484 if (err < 0) 485 return err; 486 487 settings = sensor->ext_info.settings; 488 if (enable) { 489 err = st_lsm6dsx_shub_set_odr(sensor, 490 sensor->ext_info.slv_odr); 491 if (err < 0) 492 return err; 493 } else { 494 err = st_lsm6dsx_shub_write_with_mask(sensor, 495 settings->odr_table.reg.addr, 496 settings->odr_table.reg.mask, 0); 497 if (err < 0) 498 return err; 499 } 500 501 if (settings->pwr_table.reg.addr) { 502 u8 val; 503 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); 509 if (err < 0) 510 return err; 511 } 512 513 return st_lsm6dsx_shub_master_enable(sensor, enable); 514 } 515 516 static int 517 st_lsm6dsx_shub_read_oneshot(struct st_lsm6dsx_sensor *sensor, 518 struct iio_chan_spec const *ch, 519 int *val) 520 { 521 int err, delay, len; 522 u8 data[4]; 523 524 err = st_lsm6dsx_shub_set_enable(sensor, true); 525 if (err < 0) 526 return err; 527 528 delay = 1000000000 / sensor->ext_info.slv_odr; 529 usleep_range(delay, 2 * delay); 530 531 len = min_t(int, sizeof(data), ch->scan_type.realbits >> 3); 532 err = st_lsm6dsx_shub_read(sensor, ch->address, data, len); 533 if (err < 0) 534 return err; 535 536 err = st_lsm6dsx_shub_set_enable(sensor, false); 537 if (err < 0) 538 return err; 539 540 switch (len) { 541 case 2: 542 *val = (s16)le16_to_cpu(*((__le16 *)data)); 543 break; 544 default: 545 return -EINVAL; 546 } 547 548 return IIO_VAL_INT; 549 } 550 551 static int 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) 555 { 556 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev); 557 int ret; 558 559 switch (mask) { 560 case IIO_CHAN_INFO_RAW: 561 if (!iio_device_claim_direct(iio_dev)) 562 return -EBUSY; 563 564 ret = st_lsm6dsx_shub_read_oneshot(sensor, ch, val); 565 iio_device_release_direct(iio_dev); 566 break; 567 case IIO_CHAN_INFO_SAMP_FREQ: 568 *val = sensor->ext_info.slv_odr / 1000; 569 *val2 = (sensor->ext_info.slv_odr % 1000) * 1000; 570 ret = IIO_VAL_INT_PLUS_MICRO; 571 break; 572 case IIO_CHAN_INFO_SCALE: 573 *val = 0; 574 *val2 = sensor->gain; 575 ret = IIO_VAL_INT_PLUS_MICRO; 576 break; 577 default: 578 ret = -EINVAL; 579 break; 580 } 581 582 return ret; 583 } 584 585 static int 586 st_lsm6dsx_shub_set_full_scale(struct st_lsm6dsx_sensor *sensor, 587 u32 gain) 588 { 589 const struct st_lsm6dsx_fs_table_entry *fs_table; 590 int i, err; 591 592 fs_table = &sensor->ext_info.settings->fs_table; 593 if (!fs_table->reg.addr) 594 return -ENOTSUPP; 595 596 for (i = 0; i < fs_table->fs_len; i++) { 597 if (fs_table->fs_avl[i].gain == gain) 598 break; 599 } 600 601 if (i == fs_table->fs_len) 602 return -EINVAL; 603 604 err = st_lsm6dsx_shub_write_with_mask(sensor, fs_table->reg.addr, 605 fs_table->reg.mask, 606 fs_table->fs_avl[i].val); 607 if (err < 0) 608 return err; 609 610 sensor->gain = gain; 611 612 return 0; 613 } 614 615 static int 616 __st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev, 617 struct iio_chan_spec const *chan, 618 int val, int val2, long mask) 619 { 620 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev); 621 int err; 622 623 switch (mask) { 624 case IIO_CHAN_INFO_SAMP_FREQ: { 625 struct st_lsm6dsx_hw *hw = sensor->hw; 626 struct st_lsm6dsx_sensor *ref_sensor; 627 u8 odr_val; 628 u16 data; 629 int odr; 630 631 val = val * 1000 + val2 / 1000; 632 err = st_lsm6dsx_shub_get_odr_val(sensor, val, &data); 633 if (err) 634 return err; 635 636 ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]); 637 odr = st_lsm6dsx_check_odr(ref_sensor, val, &odr_val); 638 if (odr < 0) 639 return odr; 640 641 sensor->ext_info.slv_odr = val; 642 sensor->odr = odr; 643 sensor->hwfifo_odr_mHz = odr; 644 return 0; 645 } 646 case IIO_CHAN_INFO_SCALE: 647 return st_lsm6dsx_shub_set_full_scale(sensor, val2); 648 default: 649 return -EINVAL; 650 } 651 } 652 653 static int 654 st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev, 655 struct iio_chan_spec const *chan, 656 int val, int val2, long mask) 657 { 658 int ret; 659 660 if (!iio_device_claim_direct(iio_dev)) 661 return -EBUSY; 662 663 ret = __st_lsm6dsx_shub_write_raw(iio_dev, chan, val, val2, mask); 664 665 iio_device_release_direct(iio_dev); 666 667 return ret; 668 } 669 670 static ssize_t 671 st_lsm6dsx_shub_sampling_freq_avail(struct device *dev, 672 struct device_attribute *attr, 673 char *buf) 674 { 675 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev)); 676 const struct st_lsm6dsx_ext_dev_settings *settings; 677 int i, len = 0; 678 679 settings = sensor->ext_info.settings; 680 for (i = 0; i < settings->odr_table.odr_len; i++) { 681 u32 val = settings->odr_table.odr_avl[i].milli_hz; 682 683 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%03d ", 684 val / 1000, val % 1000); 685 } 686 buf[len - 1] = '\n'; 687 688 return len; 689 } 690 691 static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev, 692 struct device_attribute *attr, 693 char *buf) 694 { 695 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev)); 696 const struct st_lsm6dsx_ext_dev_settings *settings; 697 int i, len = 0; 698 699 settings = sensor->ext_info.settings; 700 for (i = 0; i < settings->fs_table.fs_len; i++) 701 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ", 702 settings->fs_table.fs_avl[i].gain); 703 buf[len - 1] = '\n'; 704 705 return len; 706 } 707 708 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_shub_sampling_freq_avail); 709 static IIO_DEVICE_ATTR(in_scale_available, 0444, 710 st_lsm6dsx_shub_scale_avail, NULL, 0); 711 static struct attribute *st_lsm6dsx_shub_attributes[] = { 712 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 713 &iio_dev_attr_in_scale_available.dev_attr.attr, 714 NULL, 715 }; 716 717 static const struct attribute_group st_lsm6dsx_shub_attribute_group = { 718 .attrs = st_lsm6dsx_shub_attributes, 719 }; 720 721 static const struct iio_info st_lsm6dsx_shub_info = { 722 .attrs = &st_lsm6dsx_shub_attribute_group, 723 .read_raw = st_lsm6dsx_shub_read_raw, 724 .write_raw = st_lsm6dsx_shub_write_raw, 725 .hwfifo_set_watermark = st_lsm6dsx_set_watermark, 726 }; 727 728 static struct iio_dev * 729 st_lsm6dsx_shub_alloc_iiodev(struct st_lsm6dsx_hw *hw, 730 enum st_lsm6dsx_sensor_id id, 731 const struct st_lsm6dsx_ext_dev_settings *info, 732 u8 i2c_addr, const char *name) 733 { 734 enum st_lsm6dsx_sensor_id ref_id = ST_LSM6DSX_ID_ACC; 735 struct iio_chan_spec *ext_channels; 736 struct st_lsm6dsx_sensor *sensor; 737 struct iio_dev *iio_dev; 738 739 iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor)); 740 if (!iio_dev) 741 return NULL; 742 743 iio_dev->modes = INDIO_DIRECT_MODE; 744 iio_dev->info = &st_lsm6dsx_shub_info; 745 746 sensor = iio_priv(iio_dev); 747 sensor->id = id; 748 sensor->hw = hw; 749 sensor->odr = hw->settings->odr_table[ref_id].odr_avl[0].milli_hz; 750 sensor->hwfifo_odr_mHz = sensor->odr; 751 sensor->ext_info.slv_odr = info->odr_table.odr_avl[0].milli_hz; 752 sensor->gain = info->fs_table.fs_avl[0].gain; 753 sensor->ext_info.settings = info; 754 sensor->ext_info.addr = i2c_addr; 755 sensor->watermark = 1; 756 757 switch (info->id) { 758 case ST_LSM6DSX_ID_MAGN: { 759 const struct iio_chan_spec magn_channels[] = { 760 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr, 761 IIO_MOD_X, 0), 762 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 2, 763 IIO_MOD_Y, 1), 764 ST_LSM6DSX_CHANNEL(IIO_MAGN, info->out.addr + 4, 765 IIO_MOD_Z, 2), 766 IIO_CHAN_SOFT_TIMESTAMP(3), 767 }; 768 769 ext_channels = devm_kcalloc(hw->dev, ARRAY_SIZE(magn_channels), 770 sizeof(*ext_channels), GFP_KERNEL); 771 if (!ext_channels) 772 return NULL; 773 774 memcpy(ext_channels, magn_channels, sizeof(magn_channels)); 775 iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks; 776 iio_dev->channels = ext_channels; 777 iio_dev->num_channels = ARRAY_SIZE(magn_channels); 778 779 scnprintf(sensor->name, sizeof(sensor->name), "%s_magn", 780 name); 781 break; 782 } 783 default: 784 return NULL; 785 } 786 iio_dev->name = sensor->name; 787 788 return iio_dev; 789 } 790 791 static int st_lsm6dsx_shub_init_device(struct st_lsm6dsx_sensor *sensor) 792 { 793 const struct st_lsm6dsx_ext_dev_settings *settings; 794 int err; 795 796 settings = sensor->ext_info.settings; 797 if (settings->bdu.addr) { 798 err = st_lsm6dsx_shub_write_with_mask(sensor, 799 settings->bdu.addr, 800 settings->bdu.mask, 1); 801 if (err < 0) 802 return err; 803 } 804 805 if (settings->temp_comp.addr) { 806 err = st_lsm6dsx_shub_write_with_mask(sensor, 807 settings->temp_comp.addr, 808 settings->temp_comp.mask, 1); 809 if (err < 0) 810 return err; 811 } 812 813 if (settings->off_canc.addr) { 814 err = st_lsm6dsx_shub_write_with_mask(sensor, 815 settings->off_canc.addr, 816 settings->off_canc.mask, 1); 817 if (err < 0) 818 return err; 819 } 820 821 return 0; 822 } 823 824 static int 825 st_lsm6dsx_shub_check_wai(struct st_lsm6dsx_hw *hw, u8 *i2c_addr, 826 const struct st_lsm6dsx_ext_dev_settings *settings) 827 { 828 const struct st_lsm6dsx_shub_settings *hub_settings; 829 u8 config[3], data, slv_addr, slv_config = 0; 830 const struct st_lsm6dsx_reg *aux_sens; 831 struct st_lsm6dsx_sensor *sensor; 832 bool found = false; 833 int i, err; 834 835 sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]); 836 hub_settings = &hw->settings->shub_settings; 837 aux_sens = &hw->settings->shub_settings.aux_sens; 838 slv_addr = ST_LSM6DSX_SLV_ADDR(0, hub_settings->slv0_addr); 839 /* do not overwrite aux_sens */ 840 if (slv_addr + 2 == aux_sens->addr) 841 slv_config = ST_LSM6DSX_SHIFT_VAL(3, aux_sens->mask); 842 843 for (i = 0; i < ARRAY_SIZE(settings->i2c_addr); i++) { 844 if (!settings->i2c_addr[i]) 845 continue; 846 847 /* read wai slave register */ 848 config[0] = (settings->i2c_addr[i] << 1) | 0x1; 849 config[1] = settings->wai.addr; 850 config[2] = 0x1 | slv_config; 851 852 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 853 sizeof(config)); 854 if (err < 0) 855 return err; 856 857 err = st_lsm6dsx_shub_master_enable(sensor, true); 858 if (err < 0) 859 return err; 860 861 st_lsm6dsx_shub_wait_complete(hw); 862 863 err = st_lsm6dsx_shub_read_output(hw, &data, sizeof(data)); 864 865 st_lsm6dsx_shub_master_enable(sensor, false); 866 867 if (err < 0) 868 return err; 869 870 if (data != settings->wai.val) 871 continue; 872 873 *i2c_addr = settings->i2c_addr[i]; 874 found = true; 875 break; 876 } 877 878 /* reset SLV0 channel */ 879 config[0] = hub_settings->pause; 880 config[1] = 0; 881 config[2] = slv_config; 882 err = st_lsm6dsx_shub_write_reg(hw, slv_addr, config, 883 sizeof(config)); 884 if (err < 0) 885 return err; 886 887 return found ? 0 : -ENODEV; 888 } 889 890 int st_lsm6dsx_shub_probe(struct st_lsm6dsx_hw *hw, const char *name) 891 { 892 enum st_lsm6dsx_sensor_id id = ST_LSM6DSX_ID_EXT0; 893 struct st_lsm6dsx_sensor *sensor; 894 int err, i, num_ext_dev = 0; 895 u8 i2c_addr = 0; 896 897 for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_ext_dev_table); i++) { 898 err = st_lsm6dsx_shub_check_wai(hw, &i2c_addr, 899 &st_lsm6dsx_ext_dev_table[i]); 900 if (err == -ENODEV) 901 continue; 902 else if (err < 0) 903 return err; 904 905 hw->iio_devs[id] = st_lsm6dsx_shub_alloc_iiodev(hw, id, 906 &st_lsm6dsx_ext_dev_table[i], 907 i2c_addr, name); 908 if (!hw->iio_devs[id]) 909 return -ENOMEM; 910 911 sensor = iio_priv(hw->iio_devs[id]); 912 err = st_lsm6dsx_shub_init_device(sensor); 913 if (err < 0) 914 return err; 915 916 if (++num_ext_dev >= hw->settings->shub_settings.num_ext_dev) 917 break; 918 id++; 919 } 920 921 return 0; 922 } 923