1 /* 2 * STMicroelectronics st_lsm6dsx sensor driver 3 * 4 * The ST LSM6DSx IMU MEMS series consists of 3D digital accelerometer 5 * and 3D digital gyroscope system-in-package with a digital I2C/SPI serial 6 * interface standard output. 7 * LSM6DSx IMU MEMS series has a dynamic user-selectable full-scale 8 * acceleration range of +-2/+-4/+-8/+-16 g and an angular rate range of 9 * +-125/+-245/+-500/+-1000/+-2000 dps 10 * LSM6DSx series has an integrated First-In-First-Out (FIFO) buffer 11 * allowing dynamic batching of sensor data. 12 * 13 * Supported sensors: 14 * - LSM6DS3: 15 * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416 16 * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 17 * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 18 * - FIFO size: 8KB 19 * 20 * - LSM6DS3H/LSM6DSL/LSM6DSM/ISM330DLC: 21 * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416 22 * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 23 * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 24 * - FIFO size: 4KB 25 * 26 * - LSM6DSO 27 * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416 28 * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 29 * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 30 * - FIFO size: 3KB 31 * 32 * Copyright 2016 STMicroelectronics Inc. 33 * 34 * Lorenzo Bianconi <lorenzo.bianconi@st.com> 35 * Denis Ciocca <denis.ciocca@st.com> 36 * 37 * Licensed under the GPL-2. 38 */ 39 40 #include <linux/kernel.h> 41 #include <linux/module.h> 42 #include <linux/delay.h> 43 #include <linux/iio/iio.h> 44 #include <linux/iio/sysfs.h> 45 #include <linux/pm.h> 46 #include <linux/regmap.h> 47 #include <linux/bitfield.h> 48 49 #include <linux/platform_data/st_sensors_pdata.h> 50 51 #include "st_lsm6dsx.h" 52 53 #define ST_LSM6DSX_REG_INT1_ADDR 0x0d 54 #define ST_LSM6DSX_REG_INT2_ADDR 0x0e 55 #define ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK BIT(3) 56 #define ST_LSM6DSX_REG_WHOAMI_ADDR 0x0f 57 #define ST_LSM6DSX_REG_RESET_ADDR 0x12 58 #define ST_LSM6DSX_REG_RESET_MASK BIT(0) 59 #define ST_LSM6DSX_REG_BOOT_MASK BIT(7) 60 #define ST_LSM6DSX_REG_BDU_ADDR 0x12 61 #define ST_LSM6DSX_REG_BDU_MASK BIT(6) 62 #define ST_LSM6DSX_REG_INT2_ON_INT1_ADDR 0x13 63 #define ST_LSM6DSX_REG_INT2_ON_INT1_MASK BIT(5) 64 65 #define ST_LSM6DSX_REG_ACC_ODR_ADDR 0x10 66 #define ST_LSM6DSX_REG_ACC_ODR_MASK GENMASK(7, 4) 67 #define ST_LSM6DSX_REG_ACC_FS_ADDR 0x10 68 #define ST_LSM6DSX_REG_ACC_FS_MASK GENMASK(3, 2) 69 #define ST_LSM6DSX_REG_ACC_OUT_X_L_ADDR 0x28 70 #define ST_LSM6DSX_REG_ACC_OUT_Y_L_ADDR 0x2a 71 #define ST_LSM6DSX_REG_ACC_OUT_Z_L_ADDR 0x2c 72 73 #define ST_LSM6DSX_REG_GYRO_ODR_ADDR 0x11 74 #define ST_LSM6DSX_REG_GYRO_ODR_MASK GENMASK(7, 4) 75 #define ST_LSM6DSX_REG_GYRO_FS_ADDR 0x11 76 #define ST_LSM6DSX_REG_GYRO_FS_MASK GENMASK(3, 2) 77 #define ST_LSM6DSX_REG_GYRO_OUT_X_L_ADDR 0x22 78 #define ST_LSM6DSX_REG_GYRO_OUT_Y_L_ADDR 0x24 79 #define ST_LSM6DSX_REG_GYRO_OUT_Z_L_ADDR 0x26 80 81 #define ST_LSM6DSX_ACC_FS_2G_GAIN IIO_G_TO_M_S_2(61) 82 #define ST_LSM6DSX_ACC_FS_4G_GAIN IIO_G_TO_M_S_2(122) 83 #define ST_LSM6DSX_ACC_FS_8G_GAIN IIO_G_TO_M_S_2(244) 84 #define ST_LSM6DSX_ACC_FS_16G_GAIN IIO_G_TO_M_S_2(488) 85 86 #define ST_LSM6DSX_GYRO_FS_245_GAIN IIO_DEGREE_TO_RAD(8750) 87 #define ST_LSM6DSX_GYRO_FS_500_GAIN IIO_DEGREE_TO_RAD(17500) 88 #define ST_LSM6DSX_GYRO_FS_1000_GAIN IIO_DEGREE_TO_RAD(35000) 89 #define ST_LSM6DSX_GYRO_FS_2000_GAIN IIO_DEGREE_TO_RAD(70000) 90 91 static const struct st_lsm6dsx_odr_table_entry st_lsm6dsx_odr_table[] = { 92 [ST_LSM6DSX_ID_ACC] = { 93 .reg = { 94 .addr = ST_LSM6DSX_REG_ACC_ODR_ADDR, 95 .mask = ST_LSM6DSX_REG_ACC_ODR_MASK, 96 }, 97 .odr_avl[0] = { 13, 0x01 }, 98 .odr_avl[1] = { 26, 0x02 }, 99 .odr_avl[2] = { 52, 0x03 }, 100 .odr_avl[3] = { 104, 0x04 }, 101 .odr_avl[4] = { 208, 0x05 }, 102 .odr_avl[5] = { 416, 0x06 }, 103 }, 104 [ST_LSM6DSX_ID_GYRO] = { 105 .reg = { 106 .addr = ST_LSM6DSX_REG_GYRO_ODR_ADDR, 107 .mask = ST_LSM6DSX_REG_GYRO_ODR_MASK, 108 }, 109 .odr_avl[0] = { 13, 0x01 }, 110 .odr_avl[1] = { 26, 0x02 }, 111 .odr_avl[2] = { 52, 0x03 }, 112 .odr_avl[3] = { 104, 0x04 }, 113 .odr_avl[4] = { 208, 0x05 }, 114 .odr_avl[5] = { 416, 0x06 }, 115 } 116 }; 117 118 static const struct st_lsm6dsx_fs_table_entry st_lsm6dsx_fs_table[] = { 119 [ST_LSM6DSX_ID_ACC] = { 120 .reg = { 121 .addr = ST_LSM6DSX_REG_ACC_FS_ADDR, 122 .mask = ST_LSM6DSX_REG_ACC_FS_MASK, 123 }, 124 .fs_avl[0] = { ST_LSM6DSX_ACC_FS_2G_GAIN, 0x0 }, 125 .fs_avl[1] = { ST_LSM6DSX_ACC_FS_4G_GAIN, 0x2 }, 126 .fs_avl[2] = { ST_LSM6DSX_ACC_FS_8G_GAIN, 0x3 }, 127 .fs_avl[3] = { ST_LSM6DSX_ACC_FS_16G_GAIN, 0x1 }, 128 }, 129 [ST_LSM6DSX_ID_GYRO] = { 130 .reg = { 131 .addr = ST_LSM6DSX_REG_GYRO_FS_ADDR, 132 .mask = ST_LSM6DSX_REG_GYRO_FS_MASK, 133 }, 134 .fs_avl[0] = { ST_LSM6DSX_GYRO_FS_245_GAIN, 0x0 }, 135 .fs_avl[1] = { ST_LSM6DSX_GYRO_FS_500_GAIN, 0x1 }, 136 .fs_avl[2] = { ST_LSM6DSX_GYRO_FS_1000_GAIN, 0x2 }, 137 .fs_avl[3] = { ST_LSM6DSX_GYRO_FS_2000_GAIN, 0x3 }, 138 } 139 }; 140 141 static const struct st_lsm6dsx_settings st_lsm6dsx_sensor_settings[] = { 142 { 143 .wai = 0x69, 144 .max_fifo_size = 1365, 145 .id = { 146 [0] = ST_LSM6DS3_ID, 147 }, 148 .decimator = { 149 [ST_LSM6DSX_ID_ACC] = { 150 .addr = 0x08, 151 .mask = GENMASK(2, 0), 152 }, 153 [ST_LSM6DSX_ID_GYRO] = { 154 .addr = 0x08, 155 .mask = GENMASK(5, 3), 156 }, 157 }, 158 .fifo_ops = { 159 .read_fifo = st_lsm6dsx_read_fifo, 160 .fifo_th = { 161 .addr = 0x06, 162 .mask = GENMASK(11, 0), 163 }, 164 .fifo_diff = { 165 .addr = 0x3a, 166 .mask = GENMASK(11, 0), 167 }, 168 .th_wl = 3, /* 1LSB = 2B */ 169 }, 170 .ts_settings = { 171 .timer_en = { 172 .addr = 0x58, 173 .mask = BIT(7), 174 }, 175 .hr_timer = { 176 .addr = 0x5c, 177 .mask = BIT(4), 178 }, 179 .fifo_en = { 180 .addr = 0x07, 181 .mask = BIT(7), 182 }, 183 .decimator = { 184 .addr = 0x09, 185 .mask = GENMASK(5, 3), 186 }, 187 }, 188 }, 189 { 190 .wai = 0x69, 191 .max_fifo_size = 682, 192 .id = { 193 [0] = ST_LSM6DS3H_ID, 194 }, 195 .decimator = { 196 [ST_LSM6DSX_ID_ACC] = { 197 .addr = 0x08, 198 .mask = GENMASK(2, 0), 199 }, 200 [ST_LSM6DSX_ID_GYRO] = { 201 .addr = 0x08, 202 .mask = GENMASK(5, 3), 203 }, 204 }, 205 .fifo_ops = { 206 .read_fifo = st_lsm6dsx_read_fifo, 207 .fifo_th = { 208 .addr = 0x06, 209 .mask = GENMASK(11, 0), 210 }, 211 .fifo_diff = { 212 .addr = 0x3a, 213 .mask = GENMASK(11, 0), 214 }, 215 .th_wl = 3, /* 1LSB = 2B */ 216 }, 217 .ts_settings = { 218 .timer_en = { 219 .addr = 0x58, 220 .mask = BIT(7), 221 }, 222 .hr_timer = { 223 .addr = 0x5c, 224 .mask = BIT(4), 225 }, 226 .fifo_en = { 227 .addr = 0x07, 228 .mask = BIT(7), 229 }, 230 .decimator = { 231 .addr = 0x09, 232 .mask = GENMASK(5, 3), 233 }, 234 }, 235 }, 236 { 237 .wai = 0x6a, 238 .max_fifo_size = 682, 239 .id = { 240 [0] = ST_LSM6DSL_ID, 241 [1] = ST_LSM6DSM_ID, 242 [2] = ST_ISM330DLC_ID, 243 }, 244 .decimator = { 245 [ST_LSM6DSX_ID_ACC] = { 246 .addr = 0x08, 247 .mask = GENMASK(2, 0), 248 }, 249 [ST_LSM6DSX_ID_GYRO] = { 250 .addr = 0x08, 251 .mask = GENMASK(5, 3), 252 }, 253 }, 254 .fifo_ops = { 255 .read_fifo = st_lsm6dsx_read_fifo, 256 .fifo_th = { 257 .addr = 0x06, 258 .mask = GENMASK(10, 0), 259 }, 260 .fifo_diff = { 261 .addr = 0x3a, 262 .mask = GENMASK(10, 0), 263 }, 264 .th_wl = 3, /* 1LSB = 2B */ 265 }, 266 .ts_settings = { 267 .timer_en = { 268 .addr = 0x19, 269 .mask = BIT(5), 270 }, 271 .hr_timer = { 272 .addr = 0x5c, 273 .mask = BIT(4), 274 }, 275 .fifo_en = { 276 .addr = 0x07, 277 .mask = BIT(7), 278 }, 279 .decimator = { 280 .addr = 0x09, 281 .mask = GENMASK(5, 3), 282 }, 283 }, 284 }, 285 { 286 .wai = 0x6c, 287 .max_fifo_size = 512, 288 .id = { 289 [0] = ST_LSM6DSO_ID, 290 }, 291 .batch = { 292 [ST_LSM6DSX_ID_ACC] = { 293 .addr = 0x09, 294 .mask = GENMASK(3, 0), 295 }, 296 [ST_LSM6DSX_ID_GYRO] = { 297 .addr = 0x09, 298 .mask = GENMASK(7, 4), 299 }, 300 }, 301 .fifo_ops = { 302 .read_fifo = st_lsm6dsx_read_tagged_fifo, 303 .fifo_th = { 304 .addr = 0x07, 305 .mask = GENMASK(8, 0), 306 }, 307 .fifo_diff = { 308 .addr = 0x3a, 309 .mask = GENMASK(8, 0), 310 }, 311 .th_wl = 1, 312 }, 313 .ts_settings = { 314 .timer_en = { 315 .addr = 0x19, 316 .mask = BIT(5), 317 }, 318 .decimator = { 319 .addr = 0x0a, 320 .mask = GENMASK(7, 6), 321 }, 322 }, 323 .shub_settings = { 324 .page_mux = { 325 .addr = 0x01, 326 .mask = BIT(6), 327 }, 328 .master_en = { 329 .addr = 0x14, 330 .mask = BIT(2), 331 }, 332 .pullup_en = { 333 .addr = 0x14, 334 .mask = BIT(3), 335 }, 336 .aux_sens = { 337 .addr = 0x14, 338 .mask = GENMASK(1, 0), 339 }, 340 .wr_once = { 341 .addr = 0x14, 342 .mask = BIT(6), 343 }, 344 .shub_out = 0x02, 345 .slv0_addr = 0x15, 346 .dw_slv0_addr = 0x21, 347 .batch_en = BIT(3), 348 } 349 }, 350 }; 351 352 static const struct iio_chan_spec st_lsm6dsx_acc_channels[] = { 353 ST_LSM6DSX_CHANNEL(IIO_ACCEL, ST_LSM6DSX_REG_ACC_OUT_X_L_ADDR, 354 IIO_MOD_X, 0), 355 ST_LSM6DSX_CHANNEL(IIO_ACCEL, ST_LSM6DSX_REG_ACC_OUT_Y_L_ADDR, 356 IIO_MOD_Y, 1), 357 ST_LSM6DSX_CHANNEL(IIO_ACCEL, ST_LSM6DSX_REG_ACC_OUT_Z_L_ADDR, 358 IIO_MOD_Z, 2), 359 IIO_CHAN_SOFT_TIMESTAMP(3), 360 }; 361 362 static const struct iio_chan_spec st_lsm6dsx_gyro_channels[] = { 363 ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, ST_LSM6DSX_REG_GYRO_OUT_X_L_ADDR, 364 IIO_MOD_X, 0), 365 ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, ST_LSM6DSX_REG_GYRO_OUT_Y_L_ADDR, 366 IIO_MOD_Y, 1), 367 ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, ST_LSM6DSX_REG_GYRO_OUT_Z_L_ADDR, 368 IIO_MOD_Z, 2), 369 IIO_CHAN_SOFT_TIMESTAMP(3), 370 }; 371 372 int st_lsm6dsx_set_page(struct st_lsm6dsx_hw *hw, bool enable) 373 { 374 const struct st_lsm6dsx_shub_settings *hub_settings; 375 unsigned int data; 376 int err; 377 378 hub_settings = &hw->settings->shub_settings; 379 data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->page_mux.mask); 380 err = regmap_update_bits(hw->regmap, hub_settings->page_mux.addr, 381 hub_settings->page_mux.mask, data); 382 usleep_range(100, 150); 383 384 return err; 385 } 386 387 static int st_lsm6dsx_check_whoami(struct st_lsm6dsx_hw *hw, int id) 388 { 389 int err, i, j, data; 390 391 for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_sensor_settings); i++) { 392 for (j = 0; j < ST_LSM6DSX_MAX_ID; j++) { 393 if (id == st_lsm6dsx_sensor_settings[i].id[j]) 394 break; 395 } 396 if (j < ST_LSM6DSX_MAX_ID) 397 break; 398 } 399 400 if (i == ARRAY_SIZE(st_lsm6dsx_sensor_settings)) { 401 dev_err(hw->dev, "unsupported hw id [%02x]\n", id); 402 return -ENODEV; 403 } 404 405 err = regmap_read(hw->regmap, ST_LSM6DSX_REG_WHOAMI_ADDR, &data); 406 if (err < 0) { 407 dev_err(hw->dev, "failed to read whoami register\n"); 408 return err; 409 } 410 411 if (data != st_lsm6dsx_sensor_settings[i].wai) { 412 dev_err(hw->dev, "unsupported whoami [%02x]\n", data); 413 return -ENODEV; 414 } 415 416 hw->settings = &st_lsm6dsx_sensor_settings[i]; 417 418 return 0; 419 } 420 421 static int st_lsm6dsx_set_full_scale(struct st_lsm6dsx_sensor *sensor, 422 u32 gain) 423 { 424 struct st_lsm6dsx_hw *hw = sensor->hw; 425 const struct st_lsm6dsx_reg *reg; 426 unsigned int data; 427 int i, err; 428 u8 val; 429 430 for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++) 431 if (st_lsm6dsx_fs_table[sensor->id].fs_avl[i].gain == gain) 432 break; 433 434 if (i == ST_LSM6DSX_FS_LIST_SIZE) 435 return -EINVAL; 436 437 val = st_lsm6dsx_fs_table[sensor->id].fs_avl[i].val; 438 reg = &st_lsm6dsx_fs_table[sensor->id].reg; 439 data = ST_LSM6DSX_SHIFT_VAL(val, reg->mask); 440 err = st_lsm6dsx_update_bits_locked(hw, reg->addr, reg->mask, data); 441 if (err < 0) 442 return err; 443 444 sensor->gain = gain; 445 446 return 0; 447 } 448 449 int st_lsm6dsx_check_odr(struct st_lsm6dsx_sensor *sensor, u16 odr, u8 *val) 450 { 451 int i; 452 453 for (i = 0; i < ST_LSM6DSX_ODR_LIST_SIZE; i++) 454 /* 455 * ext devices can run at different odr respect to 456 * accel sensor 457 */ 458 if (st_lsm6dsx_odr_table[sensor->id].odr_avl[i].hz >= odr) 459 break; 460 461 if (i == ST_LSM6DSX_ODR_LIST_SIZE) 462 return -EINVAL; 463 464 *val = st_lsm6dsx_odr_table[sensor->id].odr_avl[i].val; 465 466 return 0; 467 } 468 469 static u16 st_lsm6dsx_check_odr_dependency(struct st_lsm6dsx_hw *hw, u16 odr, 470 enum st_lsm6dsx_sensor_id id) 471 { 472 struct st_lsm6dsx_sensor *ref = iio_priv(hw->iio_devs[id]); 473 474 if (odr > 0) { 475 if (hw->enable_mask & BIT(id)) 476 return max_t(u16, ref->odr, odr); 477 else 478 return odr; 479 } else { 480 return (hw->enable_mask & BIT(id)) ? ref->odr : 0; 481 } 482 } 483 484 static int st_lsm6dsx_set_odr(struct st_lsm6dsx_sensor *sensor, u16 req_odr) 485 { 486 struct st_lsm6dsx_sensor *ref_sensor = sensor; 487 struct st_lsm6dsx_hw *hw = sensor->hw; 488 const struct st_lsm6dsx_reg *reg; 489 unsigned int data; 490 u8 val = 0; 491 int err; 492 493 switch (sensor->id) { 494 case ST_LSM6DSX_ID_EXT0: 495 case ST_LSM6DSX_ID_EXT1: 496 case ST_LSM6DSX_ID_EXT2: 497 case ST_LSM6DSX_ID_ACC: { 498 u16 odr; 499 int i; 500 501 /* 502 * i2c embedded controller relies on the accelerometer sensor as 503 * bus read/write trigger so we need to enable accel device 504 * at odr = max(accel_odr, ext_odr) in order to properly 505 * communicate with i2c slave devices 506 */ 507 ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]); 508 for (i = ST_LSM6DSX_ID_ACC; i < ST_LSM6DSX_ID_MAX; i++) { 509 if (!hw->iio_devs[i] || i == sensor->id) 510 continue; 511 512 odr = st_lsm6dsx_check_odr_dependency(hw, req_odr, i); 513 if (odr != req_odr) 514 /* device already configured */ 515 return 0; 516 } 517 break; 518 } 519 default: 520 break; 521 } 522 523 if (req_odr > 0) { 524 err = st_lsm6dsx_check_odr(ref_sensor, req_odr, &val); 525 if (err < 0) 526 return err; 527 } 528 529 reg = &st_lsm6dsx_odr_table[ref_sensor->id].reg; 530 data = ST_LSM6DSX_SHIFT_VAL(val, reg->mask); 531 return st_lsm6dsx_update_bits_locked(hw, reg->addr, reg->mask, data); 532 } 533 534 int st_lsm6dsx_sensor_set_enable(struct st_lsm6dsx_sensor *sensor, 535 bool enable) 536 { 537 struct st_lsm6dsx_hw *hw = sensor->hw; 538 u16 odr = enable ? sensor->odr : 0; 539 int err; 540 541 err = st_lsm6dsx_set_odr(sensor, odr); 542 if (err < 0) 543 return err; 544 545 if (enable) 546 hw->enable_mask |= BIT(sensor->id); 547 else 548 hw->enable_mask &= ~BIT(sensor->id); 549 550 return 0; 551 } 552 553 static int st_lsm6dsx_read_oneshot(struct st_lsm6dsx_sensor *sensor, 554 u8 addr, int *val) 555 { 556 struct st_lsm6dsx_hw *hw = sensor->hw; 557 int err, delay; 558 __le16 data; 559 560 err = st_lsm6dsx_sensor_set_enable(sensor, true); 561 if (err < 0) 562 return err; 563 564 delay = 1000000 / sensor->odr; 565 usleep_range(delay, 2 * delay); 566 567 err = st_lsm6dsx_read_locked(hw, addr, &data, sizeof(data)); 568 if (err < 0) 569 return err; 570 571 st_lsm6dsx_sensor_set_enable(sensor, false); 572 573 *val = (s16)le16_to_cpu(data); 574 575 return IIO_VAL_INT; 576 } 577 578 static int st_lsm6dsx_read_raw(struct iio_dev *iio_dev, 579 struct iio_chan_spec const *ch, 580 int *val, int *val2, long mask) 581 { 582 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev); 583 int ret; 584 585 switch (mask) { 586 case IIO_CHAN_INFO_RAW: 587 ret = iio_device_claim_direct_mode(iio_dev); 588 if (ret) 589 break; 590 591 ret = st_lsm6dsx_read_oneshot(sensor, ch->address, val); 592 iio_device_release_direct_mode(iio_dev); 593 break; 594 case IIO_CHAN_INFO_SAMP_FREQ: 595 *val = sensor->odr; 596 ret = IIO_VAL_INT; 597 break; 598 case IIO_CHAN_INFO_SCALE: 599 *val = 0; 600 *val2 = sensor->gain; 601 ret = IIO_VAL_INT_PLUS_MICRO; 602 break; 603 default: 604 ret = -EINVAL; 605 break; 606 } 607 608 return ret; 609 } 610 611 static int st_lsm6dsx_write_raw(struct iio_dev *iio_dev, 612 struct iio_chan_spec const *chan, 613 int val, int val2, long mask) 614 { 615 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev); 616 int err; 617 618 err = iio_device_claim_direct_mode(iio_dev); 619 if (err) 620 return err; 621 622 switch (mask) { 623 case IIO_CHAN_INFO_SCALE: 624 err = st_lsm6dsx_set_full_scale(sensor, val2); 625 break; 626 case IIO_CHAN_INFO_SAMP_FREQ: { 627 u8 data; 628 629 err = st_lsm6dsx_check_odr(sensor, val, &data); 630 if (!err) 631 sensor->odr = val; 632 break; 633 } 634 default: 635 err = -EINVAL; 636 break; 637 } 638 639 iio_device_release_direct_mode(iio_dev); 640 641 return err; 642 } 643 644 int st_lsm6dsx_set_watermark(struct iio_dev *iio_dev, unsigned int val) 645 { 646 struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev); 647 struct st_lsm6dsx_hw *hw = sensor->hw; 648 int err; 649 650 if (val < 1 || val > hw->settings->max_fifo_size) 651 return -EINVAL; 652 653 mutex_lock(&hw->conf_lock); 654 655 err = st_lsm6dsx_update_watermark(sensor, val); 656 657 mutex_unlock(&hw->conf_lock); 658 659 if (err < 0) 660 return err; 661 662 sensor->watermark = val; 663 664 return 0; 665 } 666 667 static ssize_t 668 st_lsm6dsx_sysfs_sampling_frequency_avail(struct device *dev, 669 struct device_attribute *attr, 670 char *buf) 671 { 672 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev)); 673 enum st_lsm6dsx_sensor_id id = sensor->id; 674 int i, len = 0; 675 676 for (i = 0; i < ST_LSM6DSX_ODR_LIST_SIZE; i++) 677 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", 678 st_lsm6dsx_odr_table[id].odr_avl[i].hz); 679 buf[len - 1] = '\n'; 680 681 return len; 682 } 683 684 static ssize_t st_lsm6dsx_sysfs_scale_avail(struct device *dev, 685 struct device_attribute *attr, 686 char *buf) 687 { 688 struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev)); 689 enum st_lsm6dsx_sensor_id id = sensor->id; 690 int i, len = 0; 691 692 for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++) 693 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ", 694 st_lsm6dsx_fs_table[id].fs_avl[i].gain); 695 buf[len - 1] = '\n'; 696 697 return len; 698 } 699 700 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_sysfs_sampling_frequency_avail); 701 static IIO_DEVICE_ATTR(in_accel_scale_available, 0444, 702 st_lsm6dsx_sysfs_scale_avail, NULL, 0); 703 static IIO_DEVICE_ATTR(in_anglvel_scale_available, 0444, 704 st_lsm6dsx_sysfs_scale_avail, NULL, 0); 705 706 static struct attribute *st_lsm6dsx_acc_attributes[] = { 707 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 708 &iio_dev_attr_in_accel_scale_available.dev_attr.attr, 709 NULL, 710 }; 711 712 static const struct attribute_group st_lsm6dsx_acc_attribute_group = { 713 .attrs = st_lsm6dsx_acc_attributes, 714 }; 715 716 static const struct iio_info st_lsm6dsx_acc_info = { 717 .attrs = &st_lsm6dsx_acc_attribute_group, 718 .read_raw = st_lsm6dsx_read_raw, 719 .write_raw = st_lsm6dsx_write_raw, 720 .hwfifo_set_watermark = st_lsm6dsx_set_watermark, 721 }; 722 723 static struct attribute *st_lsm6dsx_gyro_attributes[] = { 724 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 725 &iio_dev_attr_in_anglvel_scale_available.dev_attr.attr, 726 NULL, 727 }; 728 729 static const struct attribute_group st_lsm6dsx_gyro_attribute_group = { 730 .attrs = st_lsm6dsx_gyro_attributes, 731 }; 732 733 static const struct iio_info st_lsm6dsx_gyro_info = { 734 .attrs = &st_lsm6dsx_gyro_attribute_group, 735 .read_raw = st_lsm6dsx_read_raw, 736 .write_raw = st_lsm6dsx_write_raw, 737 .hwfifo_set_watermark = st_lsm6dsx_set_watermark, 738 }; 739 740 static int st_lsm6dsx_of_get_drdy_pin(struct st_lsm6dsx_hw *hw, int *drdy_pin) 741 { 742 struct device_node *np = hw->dev->of_node; 743 744 if (!np) 745 return -EINVAL; 746 747 return of_property_read_u32(np, "st,drdy-int-pin", drdy_pin); 748 } 749 750 static int st_lsm6dsx_get_drdy_reg(struct st_lsm6dsx_hw *hw, u8 *drdy_reg) 751 { 752 int err = 0, drdy_pin; 753 754 if (st_lsm6dsx_of_get_drdy_pin(hw, &drdy_pin) < 0) { 755 struct st_sensors_platform_data *pdata; 756 struct device *dev = hw->dev; 757 758 pdata = (struct st_sensors_platform_data *)dev->platform_data; 759 drdy_pin = pdata ? pdata->drdy_int_pin : 1; 760 } 761 762 switch (drdy_pin) { 763 case 1: 764 *drdy_reg = ST_LSM6DSX_REG_INT1_ADDR; 765 break; 766 case 2: 767 *drdy_reg = ST_LSM6DSX_REG_INT2_ADDR; 768 break; 769 default: 770 dev_err(hw->dev, "unsupported data ready pin\n"); 771 err = -EINVAL; 772 break; 773 } 774 775 return err; 776 } 777 778 static int st_lsm6dsx_init_shub(struct st_lsm6dsx_hw *hw) 779 { 780 const struct st_lsm6dsx_shub_settings *hub_settings; 781 struct device_node *np = hw->dev->of_node; 782 struct st_sensors_platform_data *pdata; 783 unsigned int data; 784 int err = 0; 785 786 hub_settings = &hw->settings->shub_settings; 787 788 pdata = (struct st_sensors_platform_data *)hw->dev->platform_data; 789 if ((np && of_property_read_bool(np, "st,pullups")) || 790 (pdata && pdata->pullups)) { 791 err = st_lsm6dsx_set_page(hw, true); 792 if (err < 0) 793 return err; 794 795 data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->pullup_en.mask); 796 err = regmap_update_bits(hw->regmap, 797 hub_settings->pullup_en.addr, 798 hub_settings->pullup_en.mask, data); 799 800 st_lsm6dsx_set_page(hw, false); 801 802 if (err < 0) 803 return err; 804 } 805 806 if (hub_settings->aux_sens.addr) { 807 /* configure aux sensors */ 808 err = st_lsm6dsx_set_page(hw, true); 809 if (err < 0) 810 return err; 811 812 data = ST_LSM6DSX_SHIFT_VAL(3, hub_settings->aux_sens.mask); 813 err = regmap_update_bits(hw->regmap, 814 hub_settings->aux_sens.addr, 815 hub_settings->aux_sens.mask, data); 816 817 st_lsm6dsx_set_page(hw, false); 818 } 819 820 return err; 821 } 822 823 static int st_lsm6dsx_init_hw_timer(struct st_lsm6dsx_hw *hw) 824 { 825 const struct st_lsm6dsx_hw_ts_settings *ts_settings; 826 int err, val; 827 828 ts_settings = &hw->settings->ts_settings; 829 /* enable hw timestamp generation if necessary */ 830 if (ts_settings->timer_en.addr) { 831 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->timer_en.mask); 832 err = regmap_update_bits(hw->regmap, 833 ts_settings->timer_en.addr, 834 ts_settings->timer_en.mask, val); 835 if (err < 0) 836 return err; 837 } 838 839 /* enable high resolution for hw ts timer if necessary */ 840 if (ts_settings->hr_timer.addr) { 841 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->hr_timer.mask); 842 err = regmap_update_bits(hw->regmap, 843 ts_settings->hr_timer.addr, 844 ts_settings->hr_timer.mask, val); 845 if (err < 0) 846 return err; 847 } 848 849 /* enable ts queueing in FIFO if necessary */ 850 if (ts_settings->fifo_en.addr) { 851 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->fifo_en.mask); 852 err = regmap_update_bits(hw->regmap, 853 ts_settings->fifo_en.addr, 854 ts_settings->fifo_en.mask, val); 855 if (err < 0) 856 return err; 857 } 858 return 0; 859 } 860 861 static int st_lsm6dsx_init_device(struct st_lsm6dsx_hw *hw) 862 { 863 u8 drdy_int_reg; 864 int err; 865 866 /* device sw reset */ 867 err = regmap_update_bits(hw->regmap, ST_LSM6DSX_REG_RESET_ADDR, 868 ST_LSM6DSX_REG_RESET_MASK, 869 FIELD_PREP(ST_LSM6DSX_REG_RESET_MASK, 1)); 870 if (err < 0) 871 return err; 872 873 msleep(50); 874 875 /* reload trimming parameter */ 876 err = regmap_update_bits(hw->regmap, ST_LSM6DSX_REG_RESET_ADDR, 877 ST_LSM6DSX_REG_BOOT_MASK, 878 FIELD_PREP(ST_LSM6DSX_REG_BOOT_MASK, 1)); 879 if (err < 0) 880 return err; 881 882 msleep(50); 883 884 /* enable Block Data Update */ 885 err = regmap_update_bits(hw->regmap, ST_LSM6DSX_REG_BDU_ADDR, 886 ST_LSM6DSX_REG_BDU_MASK, 887 FIELD_PREP(ST_LSM6DSX_REG_BDU_MASK, 1)); 888 if (err < 0) 889 return err; 890 891 /* enable FIFO watermak interrupt */ 892 err = st_lsm6dsx_get_drdy_reg(hw, &drdy_int_reg); 893 if (err < 0) 894 return err; 895 896 err = regmap_update_bits(hw->regmap, drdy_int_reg, 897 ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK, 898 FIELD_PREP(ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK, 899 1)); 900 if (err < 0) 901 return err; 902 903 err = st_lsm6dsx_init_shub(hw); 904 if (err < 0) 905 return err; 906 907 return st_lsm6dsx_init_hw_timer(hw); 908 } 909 910 static struct iio_dev *st_lsm6dsx_alloc_iiodev(struct st_lsm6dsx_hw *hw, 911 enum st_lsm6dsx_sensor_id id, 912 const char *name) 913 { 914 struct st_lsm6dsx_sensor *sensor; 915 struct iio_dev *iio_dev; 916 917 iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor)); 918 if (!iio_dev) 919 return NULL; 920 921 iio_dev->modes = INDIO_DIRECT_MODE; 922 iio_dev->dev.parent = hw->dev; 923 iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks; 924 925 sensor = iio_priv(iio_dev); 926 sensor->id = id; 927 sensor->hw = hw; 928 sensor->odr = st_lsm6dsx_odr_table[id].odr_avl[0].hz; 929 sensor->gain = st_lsm6dsx_fs_table[id].fs_avl[0].gain; 930 sensor->watermark = 1; 931 932 switch (id) { 933 case ST_LSM6DSX_ID_ACC: 934 iio_dev->channels = st_lsm6dsx_acc_channels; 935 iio_dev->num_channels = ARRAY_SIZE(st_lsm6dsx_acc_channels); 936 iio_dev->info = &st_lsm6dsx_acc_info; 937 938 scnprintf(sensor->name, sizeof(sensor->name), "%s_accel", 939 name); 940 break; 941 case ST_LSM6DSX_ID_GYRO: 942 iio_dev->channels = st_lsm6dsx_gyro_channels; 943 iio_dev->num_channels = ARRAY_SIZE(st_lsm6dsx_gyro_channels); 944 iio_dev->info = &st_lsm6dsx_gyro_info; 945 946 scnprintf(sensor->name, sizeof(sensor->name), "%s_gyro", 947 name); 948 break; 949 default: 950 return NULL; 951 } 952 iio_dev->name = sensor->name; 953 954 return iio_dev; 955 } 956 957 int st_lsm6dsx_probe(struct device *dev, int irq, int hw_id, const char *name, 958 struct regmap *regmap) 959 { 960 const struct st_lsm6dsx_shub_settings *hub_settings; 961 struct st_lsm6dsx_hw *hw; 962 int i, err; 963 964 hw = devm_kzalloc(dev, sizeof(*hw), GFP_KERNEL); 965 if (!hw) 966 return -ENOMEM; 967 968 dev_set_drvdata(dev, (void *)hw); 969 970 mutex_init(&hw->fifo_lock); 971 mutex_init(&hw->conf_lock); 972 mutex_init(&hw->page_lock); 973 974 hw->buff = devm_kzalloc(dev, ST_LSM6DSX_BUFF_SIZE, GFP_KERNEL); 975 if (!hw->buff) 976 return -ENOMEM; 977 978 hw->dev = dev; 979 hw->irq = irq; 980 hw->regmap = regmap; 981 982 err = st_lsm6dsx_check_whoami(hw, hw_id); 983 if (err < 0) 984 return err; 985 986 for (i = 0; i < ST_LSM6DSX_ID_EXT0; i++) { 987 hw->iio_devs[i] = st_lsm6dsx_alloc_iiodev(hw, i, name); 988 if (!hw->iio_devs[i]) 989 return -ENOMEM; 990 } 991 992 err = st_lsm6dsx_init_device(hw); 993 if (err < 0) 994 return err; 995 996 hub_settings = &hw->settings->shub_settings; 997 if (hub_settings->master_en.addr) { 998 err = st_lsm6dsx_shub_probe(hw, name); 999 if (err < 0) 1000 return err; 1001 } 1002 1003 if (hw->irq > 0) { 1004 err = st_lsm6dsx_fifo_setup(hw); 1005 if (err < 0) 1006 return err; 1007 } 1008 1009 for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) { 1010 if (!hw->iio_devs[i]) 1011 continue; 1012 1013 err = devm_iio_device_register(hw->dev, hw->iio_devs[i]); 1014 if (err) 1015 return err; 1016 } 1017 1018 return 0; 1019 } 1020 EXPORT_SYMBOL(st_lsm6dsx_probe); 1021 1022 static int __maybe_unused st_lsm6dsx_suspend(struct device *dev) 1023 { 1024 struct st_lsm6dsx_hw *hw = dev_get_drvdata(dev); 1025 struct st_lsm6dsx_sensor *sensor; 1026 const struct st_lsm6dsx_reg *reg; 1027 unsigned int data; 1028 int i, err = 0; 1029 1030 for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) { 1031 if (!hw->iio_devs[i]) 1032 continue; 1033 1034 sensor = iio_priv(hw->iio_devs[i]); 1035 if (!(hw->enable_mask & BIT(sensor->id))) 1036 continue; 1037 1038 reg = &st_lsm6dsx_odr_table[sensor->id].reg; 1039 data = ST_LSM6DSX_SHIFT_VAL(0, reg->mask); 1040 err = st_lsm6dsx_update_bits_locked(hw, reg->addr, reg->mask, 1041 data); 1042 if (err < 0) 1043 return err; 1044 } 1045 1046 if (hw->fifo_mode != ST_LSM6DSX_FIFO_BYPASS) 1047 err = st_lsm6dsx_flush_fifo(hw); 1048 1049 return err; 1050 } 1051 1052 static int __maybe_unused st_lsm6dsx_resume(struct device *dev) 1053 { 1054 struct st_lsm6dsx_hw *hw = dev_get_drvdata(dev); 1055 struct st_lsm6dsx_sensor *sensor; 1056 int i, err = 0; 1057 1058 for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) { 1059 if (!hw->iio_devs[i]) 1060 continue; 1061 1062 sensor = iio_priv(hw->iio_devs[i]); 1063 if (!(hw->enable_mask & BIT(sensor->id))) 1064 continue; 1065 1066 err = st_lsm6dsx_set_odr(sensor, sensor->odr); 1067 if (err < 0) 1068 return err; 1069 } 1070 1071 if (hw->enable_mask) 1072 err = st_lsm6dsx_set_fifo_mode(hw, ST_LSM6DSX_FIFO_CONT); 1073 1074 return err; 1075 } 1076 1077 const struct dev_pm_ops st_lsm6dsx_pm_ops = { 1078 SET_SYSTEM_SLEEP_PM_OPS(st_lsm6dsx_suspend, st_lsm6dsx_resume) 1079 }; 1080 EXPORT_SYMBOL(st_lsm6dsx_pm_ops); 1081 1082 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>"); 1083 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 1084 MODULE_DESCRIPTION("STMicroelectronics st_lsm6dsx driver"); 1085 MODULE_LICENSE("GPL v2"); 1086