drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * STMicroelectronics st_lsm6dsx sensor driver
   4  *
   5  * The ST LSM6DSx IMU MEMS series consists of 3D digital accelerometer
   6  * and 3D digital gyroscope system-in-package with a digital I2C/SPI serial
   7  * interface standard output.
   8  * LSM6DSx IMU MEMS series has a dynamic user-selectable full-scale
   9  * acceleration range of +-2/+-4/+-8/+-16 g and an angular rate range of
  10  * +-125/+-245/+-500/+-1000/+-2000 dps
  11  * LSM6DSx series has an integrated First-In-First-Out (FIFO) buffer
  12  * allowing dynamic batching of sensor data.
  13  * LSM9DSx series is similar but includes an additional magnetometer, handled
  14  * by a different driver.
  15  *
  16  * Supported sensors:
  17  * - LSM6DS3:
  18  *   - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416
  19  *   - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
  20  *   - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
  21  *   - FIFO size: 8KB
  22  *
  23  * - LSM6DS3H/LSM6DSL/LSM6DSM/ISM330DLC/LSM6DS3TR-C:
  24  *   - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416
  25  *   - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
  26  *   - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
  27  *   - FIFO size: 4KB
  28  *
  29  * - LSM6DSO/LSM6DSOX/ASM330LHH/LSM6DSR/ISM330DHCX:
  30  *   - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416
  31  *   - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
  32  *   - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000
  33  *   - FIFO size: 3KB
  34  *
  35  * - LSM9DS1:
  36  *   - Accelerometer supported ODR [Hz]: 10, 50, 119, 238, 476, 952
  37  *   - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16
  38  *   - Gyroscope supported ODR [Hz]: 15, 60, 119, 238, 476, 952
  39  *   - Gyroscope supported full-scale [dps]: +-245/+-500/+-2000
  40  *   - FIFO size: 32
  41  *
  42  * Copyright 2016 STMicroelectronics Inc.
  43  *
  44  * Lorenzo Bianconi <lorenzo.bianconi@st.com>
  45  * Denis Ciocca <denis.ciocca@st.com>
  46  */
  47
  48 #include <linux/kernel.h>
  49 #include <linux/module.h>
  50 #include <linux/delay.h>
  51 #include <linux/iio/iio.h>
  52 #include <linux/iio/sysfs.h>
  53 #include <linux/pm.h>
  54 #include <linux/regmap.h>
  55 #include <linux/bitfield.h>
  56
  57 #include <linux/platform_data/st_sensors_pdata.h>
  58
  59 #include "st_lsm6dsx.h"
  60
  61 #define ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK        BIT(3)
  62 #define ST_LSM6DSX_REG_WHOAMI_ADDR              0x0f
  63 #define ST_LSM6DSX_REG_RESET_MASK               BIT(0)
  64 #define ST_LSM6DSX_REG_BOOT_MASK                BIT(7)
  65 #define ST_LSM6DSX_REG_BDU_ADDR                 0x12
  66 #define ST_LSM6DSX_REG_BDU_MASK                 BIT(6)
  67
  68 static const struct iio_chan_spec st_lsm6dsx_acc_channels[] = {
  69         ST_LSM6DSX_CHANNEL(IIO_ACCEL, 0x28, IIO_MOD_X, 0),
  70         ST_LSM6DSX_CHANNEL(IIO_ACCEL, 0x2a, IIO_MOD_Y, 1),
  71         ST_LSM6DSX_CHANNEL(IIO_ACCEL, 0x2c, IIO_MOD_Z, 2),
  72         IIO_CHAN_SOFT_TIMESTAMP(3),
  73 };
  74
  75 static const struct iio_chan_spec st_lsm6dsx_gyro_channels[] = {
  76         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x22, IIO_MOD_X, 0),
  77         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x24, IIO_MOD_Y, 1),
  78         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x26, IIO_MOD_Z, 2),
  79         IIO_CHAN_SOFT_TIMESTAMP(3),
  80 };
  81
  82 static const struct iio_chan_spec st_lsm6ds0_gyro_channels[] = {
  83         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x18, IIO_MOD_X, 0),
  84         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x1a, IIO_MOD_Y, 1),
  85         ST_LSM6DSX_CHANNEL(IIO_ANGL_VEL, 0x1c, IIO_MOD_Z, 2),
  86         IIO_CHAN_SOFT_TIMESTAMP(3),
  87 };
  88
  89 static const struct st_lsm6dsx_settings st_lsm6dsx_sensor_settings[] = {
  90         {
  91                 .wai = 0x68,
  92                 .int1_addr = 0x0c,
  93                 .int2_addr = 0x0d,
  94                 .reset_addr = 0x22,
  95                 .max_fifo_size = 32,
  96                 .id = {
  97                         {
  98                                 .hw_id = ST_LSM9DS1_ID,
  99                                 .name = ST_LSM9DS1_DEV_NAME,
 100                         },
 101                 },
 102                 .channels = {
 103                         [ST_LSM6DSX_ID_ACC] = {
 104                                 .chan = st_lsm6dsx_acc_channels,
 105                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 106                         },
 107                         [ST_LSM6DSX_ID_GYRO] = {
 108                                 .chan = st_lsm6ds0_gyro_channels,
 109                                 .len = ARRAY_SIZE(st_lsm6ds0_gyro_channels),
 110                         },
 111                 },
 112                 .odr_table = {
 113                         [ST_LSM6DSX_ID_ACC] = {
 114                                 .reg = {
 115                                         .addr = 0x20,
 116                                         .mask = GENMASK(7, 5),
 117                                 },
 118                                 .odr_avl[0] = {  10, 0x01 },
 119                                 .odr_avl[1] = {  50, 0x02 },
 120                                 .odr_avl[2] = { 119, 0x03 },
 121                                 .odr_avl[3] = { 238, 0x04 },
 122                                 .odr_avl[4] = { 476, 0x05 },
 123                                 .odr_avl[5] = { 952, 0x06 },
 124                         },
 125                         [ST_LSM6DSX_ID_GYRO] = {
 126                                 .reg = {
 127                                         .addr = 0x10,
 128                                         .mask = GENMASK(7, 5),
 129                                 },
 130                                 .odr_avl[0] = {  15, 0x01 },
 131                                 .odr_avl[1] = {  60, 0x02 },
 132                                 .odr_avl[2] = { 119, 0x03 },
 133                                 .odr_avl[3] = { 238, 0x04 },
 134                                 .odr_avl[4] = { 476, 0x05 },
 135                                 .odr_avl[5] = { 952, 0x06 },
 136                         },
 137                 },
 138                 .fs_table = {
 139                         [ST_LSM6DSX_ID_ACC] = {
 140                                 .reg = {
 141                                         .addr = 0x20,
 142                                         .mask = GENMASK(4, 3),
 143                                 },
 144                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 145                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 146                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 147                                 .fs_avl[3] = { IIO_G_TO_M_S_2(732), 0x1 },
 148                         },
 149                         [ST_LSM6DSX_ID_GYRO] = {
 150                                 .reg = {
 151                                         .addr = 0x10,
 152                                         .mask = GENMASK(4, 3),
 153                                 },
 154                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(245), 0x0 },
 155                                 .fs_avl[1] = {  IIO_DEGREE_TO_RAD(500), 0x1 },
 156                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(2000), 0x3 },
 157                         },
 158                 },
 159         },
 160         {
 161                 .wai = 0x69,
 162                 .int1_addr = 0x0d,
 163                 .int2_addr = 0x0e,
 164                 .reset_addr = 0x12,
 165                 .max_fifo_size = 1365,
 166                 .id = {
 167                         {
 168                                 .hw_id = ST_LSM6DS3_ID,
 169                                 .name = ST_LSM6DS3_DEV_NAME,
 170                         },
 171                 },
 172                 .channels = {
 173                         [ST_LSM6DSX_ID_ACC] = {
 174                                 .chan = st_lsm6dsx_acc_channels,
 175                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 176                         },
 177                         [ST_LSM6DSX_ID_GYRO] = {
 178                                 .chan = st_lsm6dsx_gyro_channels,
 179                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 180                         },
 181                 },
 182                 .odr_table = {
 183                         [ST_LSM6DSX_ID_ACC] = {
 184                                 .reg = {
 185                                         .addr = 0x10,
 186                                         .mask = GENMASK(7, 4),
 187                                 },
 188                                 .odr_avl[0] = {  13, 0x01 },
 189                                 .odr_avl[1] = {  26, 0x02 },
 190                                 .odr_avl[2] = {  52, 0x03 },
 191                                 .odr_avl[3] = { 104, 0x04 },
 192                                 .odr_avl[4] = { 208, 0x05 },
 193                                 .odr_avl[5] = { 416, 0x06 },
 194                         },
 195                         [ST_LSM6DSX_ID_GYRO] = {
 196                                 .reg = {
 197                                         .addr = 0x11,
 198                                         .mask = GENMASK(7, 4),
 199                                 },
 200                                 .odr_avl[0] = {  13, 0x01 },
 201                                 .odr_avl[1] = {  26, 0x02 },
 202                                 .odr_avl[2] = {  52, 0x03 },
 203                                 .odr_avl[3] = { 104, 0x04 },
 204                                 .odr_avl[4] = { 208, 0x05 },
 205                                 .odr_avl[5] = { 416, 0x06 },
 206                         },
 207                 },
 208                 .fs_table = {
 209                         [ST_LSM6DSX_ID_ACC] = {
 210                                 .reg = {
 211                                         .addr = 0x10,
 212                                         .mask = GENMASK(3, 2),
 213                                 },
 214                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 215                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 216                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 217                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 218                         },
 219                         [ST_LSM6DSX_ID_GYRO] = {
 220                                 .reg = {
 221                                         .addr = 0x11,
 222                                         .mask = GENMASK(3, 2),
 223                                 },
 224                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 225                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 226                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 227                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 228                         },
 229                 },
 230                 .decimator = {
 231                         [ST_LSM6DSX_ID_ACC] = {
 232                                 .addr = 0x08,
 233                                 .mask = GENMASK(2, 0),
 234                         },
 235                         [ST_LSM6DSX_ID_GYRO] = {
 236                                 .addr = 0x08,
 237                                 .mask = GENMASK(5, 3),
 238                         },
 239                 },
 240                 .fifo_ops = {
 241                         .update_fifo = st_lsm6dsx_update_fifo,
 242                         .read_fifo = st_lsm6dsx_read_fifo,
 243                         .fifo_th = {
 244                                 .addr = 0x06,
 245                                 .mask = GENMASK(11, 0),
 246                         },
 247                         .fifo_diff = {
 248                                 .addr = 0x3a,
 249                                 .mask = GENMASK(11, 0),
 250                         },
 251                         .th_wl = 3, /* 1LSB = 2B */
 252                 },
 253                 .ts_settings = {
 254                         .timer_en = {
 255                                 .addr = 0x58,
 256                                 .mask = BIT(7),
 257                         },
 258                         .hr_timer = {
 259                                 .addr = 0x5c,
 260                                 .mask = BIT(4),
 261                         },
 262                         .fifo_en = {
 263                                 .addr = 0x07,
 264                                 .mask = BIT(7),
 265                         },
 266                         .decimator = {
 267                                 .addr = 0x09,
 268                                 .mask = GENMASK(5, 3),
 269                         },
 270                 },
 271         },
 272         {
 273                 .wai = 0x69,
 274                 .int1_addr = 0x0d,
 275                 .int2_addr = 0x0e,
 276                 .reset_addr = 0x12,
 277                 .max_fifo_size = 682,
 278                 .id = {
 279                         {
 280                                 .hw_id = ST_LSM6DS3H_ID,
 281                                 .name = ST_LSM6DS3H_DEV_NAME,
 282                         },
 283                 },
 284                 .channels = {
 285                         [ST_LSM6DSX_ID_ACC] = {
 286                                 .chan = st_lsm6dsx_acc_channels,
 287                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 288                         },
 289                         [ST_LSM6DSX_ID_GYRO] = {
 290                                 .chan = st_lsm6dsx_gyro_channels,
 291                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 292                         },
 293                 },
 294                 .odr_table = {
 295                         [ST_LSM6DSX_ID_ACC] = {
 296                                 .reg = {
 297                                         .addr = 0x10,
 298                                         .mask = GENMASK(7, 4),
 299                                 },
 300                                 .odr_avl[0] = {  13, 0x01 },
 301                                 .odr_avl[1] = {  26, 0x02 },
 302                                 .odr_avl[2] = {  52, 0x03 },
 303                                 .odr_avl[3] = { 104, 0x04 },
 304                                 .odr_avl[4] = { 208, 0x05 },
 305                                 .odr_avl[5] = { 416, 0x06 },
 306                         },
 307                         [ST_LSM6DSX_ID_GYRO] = {
 308                                 .reg = {
 309                                         .addr = 0x11,
 310                                         .mask = GENMASK(7, 4),
 311                                 },
 312                                 .odr_avl[0] = {  13, 0x01 },
 313                                 .odr_avl[1] = {  26, 0x02 },
 314                                 .odr_avl[2] = {  52, 0x03 },
 315                                 .odr_avl[3] = { 104, 0x04 },
 316                                 .odr_avl[4] = { 208, 0x05 },
 317                                 .odr_avl[5] = { 416, 0x06 },
 318                         },
 319                 },
 320                 .fs_table = {
 321                         [ST_LSM6DSX_ID_ACC] = {
 322                                 .reg = {
 323                                         .addr = 0x10,
 324                                         .mask = GENMASK(3, 2),
 325                                 },
 326                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 327                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 328                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 329                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 330                         },
 331                         [ST_LSM6DSX_ID_GYRO] = {
 332                                 .reg = {
 333                                         .addr = 0x11,
 334                                         .mask = GENMASK(3, 2),
 335                                 },
 336                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 337                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 338                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 339                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 340                         },
 341                 },
 342                 .decimator = {
 343                         [ST_LSM6DSX_ID_ACC] = {
 344                                 .addr = 0x08,
 345                                 .mask = GENMASK(2, 0),
 346                         },
 347                         [ST_LSM6DSX_ID_GYRO] = {
 348                                 .addr = 0x08,
 349                                 .mask = GENMASK(5, 3),
 350                         },
 351                 },
 352                 .fifo_ops = {
 353                         .update_fifo = st_lsm6dsx_update_fifo,
 354                         .read_fifo = st_lsm6dsx_read_fifo,
 355                         .fifo_th = {
 356                                 .addr = 0x06,
 357                                 .mask = GENMASK(11, 0),
 358                         },
 359                         .fifo_diff = {
 360                                 .addr = 0x3a,
 361                                 .mask = GENMASK(11, 0),
 362                         },
 363                         .th_wl = 3, /* 1LSB = 2B */
 364                 },
 365                 .ts_settings = {
 366                         .timer_en = {
 367                                 .addr = 0x58,
 368                                 .mask = BIT(7),
 369                         },
 370                         .hr_timer = {
 371                                 .addr = 0x5c,
 372                                 .mask = BIT(4),
 373                         },
 374                         .fifo_en = {
 375                                 .addr = 0x07,
 376                                 .mask = BIT(7),
 377                         },
 378                         .decimator = {
 379                                 .addr = 0x09,
 380                                 .mask = GENMASK(5, 3),
 381                         },
 382                 },
 383         },
 384         {
 385                 .wai = 0x6a,
 386                 .int1_addr = 0x0d,
 387                 .int2_addr = 0x0e,
 388                 .reset_addr = 0x12,
 389                 .max_fifo_size = 682,
 390                 .id = {
 391                         {
 392                                 .hw_id = ST_LSM6DSL_ID,
 393                                 .name = ST_LSM6DSL_DEV_NAME,
 394                         }, {
 395                                 .hw_id = ST_LSM6DSM_ID,
 396                                 .name = ST_LSM6DSM_DEV_NAME,
 397                         }, {
 398                                 .hw_id = ST_ISM330DLC_ID,
 399                                 .name = ST_ISM330DLC_DEV_NAME,
 400                         }, {
 401                                 .hw_id = ST_LSM6DS3TRC_ID,
 402                                 .name = ST_LSM6DS3TRC_DEV_NAME,
 403                         },
 404                 },
 405                 .channels = {
 406                         [ST_LSM6DSX_ID_ACC] = {
 407                                 .chan = st_lsm6dsx_acc_channels,
 408                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 409                         },
 410                         [ST_LSM6DSX_ID_GYRO] = {
 411                                 .chan = st_lsm6dsx_gyro_channels,
 412                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 413                         },
 414                 },
 415                 .odr_table = {
 416                         [ST_LSM6DSX_ID_ACC] = {
 417                                 .reg = {
 418                                         .addr = 0x10,
 419                                         .mask = GENMASK(7, 4),
 420                                 },
 421                                 .odr_avl[0] = {  13, 0x01 },
 422                                 .odr_avl[1] = {  26, 0x02 },
 423                                 .odr_avl[2] = {  52, 0x03 },
 424                                 .odr_avl[3] = { 104, 0x04 },
 425                                 .odr_avl[4] = { 208, 0x05 },
 426                                 .odr_avl[5] = { 416, 0x06 },
 427                         },
 428                         [ST_LSM6DSX_ID_GYRO] = {
 429                                 .reg = {
 430                                         .addr = 0x11,
 431                                         .mask = GENMASK(7, 4),
 432                                 },
 433                                 .odr_avl[0] = {  13, 0x01 },
 434                                 .odr_avl[1] = {  26, 0x02 },
 435                                 .odr_avl[2] = {  52, 0x03 },
 436                                 .odr_avl[3] = { 104, 0x04 },
 437                                 .odr_avl[4] = { 208, 0x05 },
 438                                 .odr_avl[5] = { 416, 0x06 },
 439                         },
 440                 },
 441                 .fs_table = {
 442                         [ST_LSM6DSX_ID_ACC] = {
 443                                 .reg = {
 444                                         .addr = 0x10,
 445                                         .mask = GENMASK(3, 2),
 446                                 },
 447                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 448                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 449                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 450                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 451                         },
 452                         [ST_LSM6DSX_ID_GYRO] = {
 453                                 .reg = {
 454                                         .addr = 0x11,
 455                                         .mask = GENMASK(3, 2),
 456                                 },
 457                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 458                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 459                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 460                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 461                         },
 462                 },
 463                 .decimator = {
 464                         [ST_LSM6DSX_ID_ACC] = {
 465                                 .addr = 0x08,
 466                                 .mask = GENMASK(2, 0),
 467                         },
 468                         [ST_LSM6DSX_ID_GYRO] = {
 469                                 .addr = 0x08,
 470                                 .mask = GENMASK(5, 3),
 471                         },
 472                 },
 473                 .fifo_ops = {
 474                         .update_fifo = st_lsm6dsx_update_fifo,
 475                         .read_fifo = st_lsm6dsx_read_fifo,
 476                         .fifo_th = {
 477                                 .addr = 0x06,
 478                                 .mask = GENMASK(10, 0),
 479                         },
 480                         .fifo_diff = {
 481                                 .addr = 0x3a,
 482                                 .mask = GENMASK(10, 0),
 483                         },
 484                         .th_wl = 3, /* 1LSB = 2B */
 485                 },
 486                 .ts_settings = {
 487                         .timer_en = {
 488                                 .addr = 0x19,
 489                                 .mask = BIT(5),
 490                         },
 491                         .hr_timer = {
 492                                 .addr = 0x5c,
 493                                 .mask = BIT(4),
 494                         },
 495                         .fifo_en = {
 496                                 .addr = 0x07,
 497                                 .mask = BIT(7),
 498                         },
 499                         .decimator = {
 500                                 .addr = 0x09,
 501                                 .mask = GENMASK(5, 3),
 502                         },
 503                 },
 504         },
 505         {
 506                 .wai = 0x6c,
 507                 .int1_addr = 0x0d,
 508                 .int2_addr = 0x0e,
 509                 .reset_addr = 0x12,
 510                 .max_fifo_size = 512,
 511                 .id = {
 512                         {
 513                                 .hw_id = ST_LSM6DSO_ID,
 514                                 .name = ST_LSM6DSO_DEV_NAME,
 515                         }, {
 516                                 .hw_id = ST_LSM6DSOX_ID,
 517                                 .name = ST_LSM6DSOX_DEV_NAME,
 518                         },
 519                 },
 520                 .channels = {
 521                         [ST_LSM6DSX_ID_ACC] = {
 522                                 .chan = st_lsm6dsx_acc_channels,
 523                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 524                         },
 525                         [ST_LSM6DSX_ID_GYRO] = {
 526                                 .chan = st_lsm6dsx_gyro_channels,
 527                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 528                         },
 529                 },
 530                 .odr_table = {
 531                         [ST_LSM6DSX_ID_ACC] = {
 532                                 .reg = {
 533                                         .addr = 0x10,
 534                                         .mask = GENMASK(7, 4),
 535                                 },
 536                                 .odr_avl[0] = {  13, 0x01 },
 537                                 .odr_avl[1] = {  26, 0x02 },
 538                                 .odr_avl[2] = {  52, 0x03 },
 539                                 .odr_avl[3] = { 104, 0x04 },
 540                                 .odr_avl[4] = { 208, 0x05 },
 541                                 .odr_avl[5] = { 416, 0x06 },
 542                         },
 543                         [ST_LSM6DSX_ID_GYRO] = {
 544                                 .reg = {
 545                                         .addr = 0x11,
 546                                         .mask = GENMASK(7, 4),
 547                                 },
 548                                 .odr_avl[0] = {  13, 0x01 },
 549                                 .odr_avl[1] = {  26, 0x02 },
 550                                 .odr_avl[2] = {  52, 0x03 },
 551                                 .odr_avl[3] = { 104, 0x04 },
 552                                 .odr_avl[4] = { 208, 0x05 },
 553                                 .odr_avl[5] = { 416, 0x06 },
 554                         },
 555                 },
 556                 .fs_table = {
 557                         [ST_LSM6DSX_ID_ACC] = {
 558                                 .reg = {
 559                                         .addr = 0x10,
 560                                         .mask = GENMASK(3, 2),
 561                                 },
 562                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 563                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 564                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 565                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 566                         },
 567                         [ST_LSM6DSX_ID_GYRO] = {
 568                                 .reg = {
 569                                         .addr = 0x11,
 570                                         .mask = GENMASK(3, 2),
 571                                 },
 572                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 573                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 574                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 575                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 576                         },
 577                 },
 578                 .batch = {
 579                         [ST_LSM6DSX_ID_ACC] = {
 580                                 .addr = 0x09,
 581                                 .mask = GENMASK(3, 0),
 582                         },
 583                         [ST_LSM6DSX_ID_GYRO] = {
 584                                 .addr = 0x09,
 585                                 .mask = GENMASK(7, 4),
 586                         },
 587                 },
 588                 .fifo_ops = {
 589                         .update_fifo = st_lsm6dsx_update_fifo,
 590                         .read_fifo = st_lsm6dsx_read_tagged_fifo,
 591                         .fifo_th = {
 592                                 .addr = 0x07,
 593                                 .mask = GENMASK(8, 0),
 594                         },
 595                         .fifo_diff = {
 596                                 .addr = 0x3a,
 597                                 .mask = GENMASK(9, 0),
 598                         },
 599                         .th_wl = 1,
 600                 },
 601                 .ts_settings = {
 602                         .timer_en = {
 603                                 .addr = 0x19,
 604                                 .mask = BIT(5),
 605                         },
 606                         .decimator = {
 607                                 .addr = 0x0a,
 608                                 .mask = GENMASK(7, 6),
 609                         },
 610                 },
 611                 .shub_settings = {
 612                         .page_mux = {
 613                                 .addr = 0x01,
 614                                 .mask = BIT(6),
 615                         },
 616                         .master_en = {
 617                                 .addr = 0x14,
 618                                 .mask = BIT(2),
 619                         },
 620                         .pullup_en = {
 621                                 .addr = 0x14,
 622                                 .mask = BIT(3),
 623                         },
 624                         .aux_sens = {
 625                                 .addr = 0x14,
 626                                 .mask = GENMASK(1, 0),
 627                         },
 628                         .wr_once = {
 629                                 .addr = 0x14,
 630                                 .mask = BIT(6),
 631                         },
 632                         .shub_out = 0x02,
 633                         .slv0_addr = 0x15,
 634                         .dw_slv0_addr = 0x21,
 635                         .batch_en = BIT(3),
 636                 }
 637         },
 638         {
 639                 .wai = 0x6b,
 640                 .int1_addr = 0x0d,
 641                 .int2_addr = 0x0e,
 642                 .reset_addr = 0x12,
 643                 .max_fifo_size = 512,
 644                 .id = {
 645                         {
 646                                 .hw_id = ST_ASM330LHH_ID,
 647                                 .name = ST_ASM330LHH_DEV_NAME,
 648                         },
 649                 },
 650                 .channels = {
 651                         [ST_LSM6DSX_ID_ACC] = {
 652                                 .chan = st_lsm6dsx_acc_channels,
 653                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 654                         },
 655                         [ST_LSM6DSX_ID_GYRO] = {
 656                                 .chan = st_lsm6dsx_gyro_channels,
 657                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 658                         },
 659                 },
 660                 .odr_table = {
 661                         [ST_LSM6DSX_ID_ACC] = {
 662                                 .reg = {
 663                                         .addr = 0x10,
 664                                         .mask = GENMASK(7, 4),
 665                                 },
 666                                 .odr_avl[0] = {  13, 0x01 },
 667                                 .odr_avl[1] = {  26, 0x02 },
 668                                 .odr_avl[2] = {  52, 0x03 },
 669                                 .odr_avl[3] = { 104, 0x04 },
 670                                 .odr_avl[4] = { 208, 0x05 },
 671                                 .odr_avl[5] = { 416, 0x06 },
 672                         },
 673                         [ST_LSM6DSX_ID_GYRO] = {
 674                                 .reg = {
 675                                         .addr = 0x11,
 676                                         .mask = GENMASK(7, 4),
 677                                 },
 678                                 .odr_avl[0] = {  13, 0x01 },
 679                                 .odr_avl[1] = {  26, 0x02 },
 680                                 .odr_avl[2] = {  52, 0x03 },
 681                                 .odr_avl[3] = { 104, 0x04 },
 682                                 .odr_avl[4] = { 208, 0x05 },
 683                                 .odr_avl[5] = { 416, 0x06 },
 684                         },
 685                 },
 686                 .fs_table = {
 687                         [ST_LSM6DSX_ID_ACC] = {
 688                                 .reg = {
 689                                         .addr = 0x10,
 690                                         .mask = GENMASK(3, 2),
 691                                 },
 692                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 693                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 694                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 695                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 696                         },
 697                         [ST_LSM6DSX_ID_GYRO] = {
 698                                 .reg = {
 699                                         .addr = 0x11,
 700                                         .mask = GENMASK(3, 2),
 701                                 },
 702                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 703                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 704                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 705                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 706                         },
 707                 },
 708                 .batch = {
 709                         [ST_LSM6DSX_ID_ACC] = {
 710                                 .addr = 0x09,
 711                                 .mask = GENMASK(3, 0),
 712                         },
 713                         [ST_LSM6DSX_ID_GYRO] = {
 714                                 .addr = 0x09,
 715                                 .mask = GENMASK(7, 4),
 716                         },
 717                 },
 718                 .fifo_ops = {
 719                         .update_fifo = st_lsm6dsx_update_fifo,
 720                         .read_fifo = st_lsm6dsx_read_tagged_fifo,
 721                         .fifo_th = {
 722                                 .addr = 0x07,
 723                                 .mask = GENMASK(8, 0),
 724                         },
 725                         .fifo_diff = {
 726                                 .addr = 0x3a,
 727                                 .mask = GENMASK(9, 0),
 728                         },
 729                         .th_wl = 1,
 730                 },
 731                 .ts_settings = {
 732                         .timer_en = {
 733                                 .addr = 0x19,
 734                                 .mask = BIT(5),
 735                         },
 736                         .decimator = {
 737                                 .addr = 0x0a,
 738                                 .mask = GENMASK(7, 6),
 739                         },
 740                 },
 741         },
 742         {
 743                 .wai = 0x6b,
 744                 .int1_addr = 0x0d,
 745                 .int2_addr = 0x0e,
 746                 .reset_addr = 0x12,
 747                 .max_fifo_size = 512,
 748                 .id = {
 749                         {
 750                                 .hw_id = ST_LSM6DSR_ID,
 751                                 .name = ST_LSM6DSR_DEV_NAME,
 752                         }, {
 753                                 .hw_id = ST_ISM330DHCX_ID,
 754                                 .name = ST_ISM330DHCX_DEV_NAME,
 755                         },
 756                 },
 757                 .channels = {
 758                         [ST_LSM6DSX_ID_ACC] = {
 759                                 .chan = st_lsm6dsx_acc_channels,
 760                                 .len = ARRAY_SIZE(st_lsm6dsx_acc_channels),
 761                         },
 762                         [ST_LSM6DSX_ID_GYRO] = {
 763                                 .chan = st_lsm6dsx_gyro_channels,
 764                                 .len = ARRAY_SIZE(st_lsm6dsx_gyro_channels),
 765                         },
 766                 },
 767                 .odr_table = {
 768                         [ST_LSM6DSX_ID_ACC] = {
 769                                 .reg = {
 770                                         .addr = 0x10,
 771                                         .mask = GENMASK(7, 4),
 772                                 },
 773                                 .odr_avl[0] = {  13, 0x01 },
 774                                 .odr_avl[1] = {  26, 0x02 },
 775                                 .odr_avl[2] = {  52, 0x03 },
 776                                 .odr_avl[3] = { 104, 0x04 },
 777                                 .odr_avl[4] = { 208, 0x05 },
 778                                 .odr_avl[5] = { 416, 0x06 },
 779                         },
 780                         [ST_LSM6DSX_ID_GYRO] = {
 781                                 .reg = {
 782                                         .addr = 0x11,
 783                                         .mask = GENMASK(7, 4),
 784                                 },
 785                                 .odr_avl[0] = {  13, 0x01 },
 786                                 .odr_avl[1] = {  26, 0x02 },
 787                                 .odr_avl[2] = {  52, 0x03 },
 788                                 .odr_avl[3] = { 104, 0x04 },
 789                                 .odr_avl[4] = { 208, 0x05 },
 790                                 .odr_avl[5] = { 416, 0x06 },
 791                         },
 792                 },
 793                 .fs_table = {
 794                         [ST_LSM6DSX_ID_ACC] = {
 795                                 .reg = {
 796                                         .addr = 0x10,
 797                                         .mask = GENMASK(3, 2),
 798                                 },
 799                                 .fs_avl[0] = {  IIO_G_TO_M_S_2(61), 0x0 },
 800                                 .fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 801                                 .fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 802                                 .fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
 803                         },
 804                         [ST_LSM6DSX_ID_GYRO] = {
 805                                 .reg = {
 806                                         .addr = 0x11,
 807                                         .mask = GENMASK(3, 2),
 808                                 },
 809                                 .fs_avl[0] = {  IIO_DEGREE_TO_RAD(8750), 0x0 },
 810                                 .fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 811                                 .fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 812                                 .fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
 813                         },
 814                 },
 815                 .batch = {
 816                         [ST_LSM6DSX_ID_ACC] = {
 817                                 .addr = 0x09,
 818                                 .mask = GENMASK(3, 0),
 819                         },
 820                         [ST_LSM6DSX_ID_GYRO] = {
 821                                 .addr = 0x09,
 822                                 .mask = GENMASK(7, 4),
 823                         },
 824                 },
 825                 .fifo_ops = {
 826                         .update_fifo = st_lsm6dsx_update_fifo,
 827                         .read_fifo = st_lsm6dsx_read_tagged_fifo,
 828                         .fifo_th = {
 829                                 .addr = 0x07,
 830                                 .mask = GENMASK(8, 0),
 831                         },
 832                         .fifo_diff = {
 833                                 .addr = 0x3a,
 834                                 .mask = GENMASK(9, 0),
 835                         },
 836                         .th_wl = 1,
 837                 },
 838                 .ts_settings = {
 839                         .timer_en = {
 840                                 .addr = 0x19,
 841                                 .mask = BIT(5),
 842                         },
 843                         .decimator = {
 844                                 .addr = 0x0a,
 845                                 .mask = GENMASK(7, 6),
 846                         },
 847                 },
 848                 .shub_settings = {
 849                         .page_mux = {
 850                                 .addr = 0x01,
 851                                 .mask = BIT(6),
 852                         },
 853                         .master_en = {
 854                                 .addr = 0x14,
 855                                 .mask = BIT(2),
 856                         },
 857                         .pullup_en = {
 858                                 .addr = 0x14,
 859                                 .mask = BIT(3),
 860                         },
 861                         .aux_sens = {
 862                                 .addr = 0x14,
 863                                 .mask = GENMASK(1, 0),
 864                         },
 865                         .wr_once = {
 866                                 .addr = 0x14,
 867                                 .mask = BIT(6),
 868                         },
 869                         .shub_out = 0x02,
 870                         .slv0_addr = 0x15,
 871                         .dw_slv0_addr = 0x21,
 872                         .batch_en = BIT(3),
 873                 }
 874         },
 875 };
 876
 877 int st_lsm6dsx_set_page(struct st_lsm6dsx_hw *hw, bool enable)
 878 {
 879         const struct st_lsm6dsx_shub_settings *hub_settings;
 880         unsigned int data;
 881         int err;
 882
 883         hub_settings = &hw->settings->shub_settings;
 884         data = ST_LSM6DSX_SHIFT_VAL(enable, hub_settings->page_mux.mask);
 885         err = regmap_update_bits(hw->regmap, hub_settings->page_mux.addr,
 886                                  hub_settings->page_mux.mask, data);
 887         usleep_range(100, 150);
 888
 889         return err;
 890 }
 891
 892 static int st_lsm6dsx_check_whoami(struct st_lsm6dsx_hw *hw, int id,
 893                                    const char **name)
 894 {
 895         int err, i, j, data;
 896
 897         for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_sensor_settings); i++) {
 898                 for (j = 0; j < ST_LSM6DSX_MAX_ID; j++) {
 899                         if (id == st_lsm6dsx_sensor_settings[i].id[j].hw_id)
 900                                 break;
 901                 }
 902                 if (j < ST_LSM6DSX_MAX_ID)
 903                         break;
 904         }
 905
 906         if (i == ARRAY_SIZE(st_lsm6dsx_sensor_settings)) {
 907                 dev_err(hw->dev, "unsupported hw id [%02x]\n", id);
 908                 return -ENODEV;
 909         }
 910
 911         err = regmap_read(hw->regmap, ST_LSM6DSX_REG_WHOAMI_ADDR, &data);
 912         if (err < 0) {
 913                 dev_err(hw->dev, "failed to read whoami register\n");
 914                 return err;
 915         }
 916
 917         if (data != st_lsm6dsx_sensor_settings[i].wai) {
 918                 dev_err(hw->dev, "unsupported whoami [%02x]\n", data);
 919                 return -ENODEV;
 920         }
 921
 922         *name = st_lsm6dsx_sensor_settings[i].id[j].name;
 923         hw->settings = &st_lsm6dsx_sensor_settings[i];
 924
 925         return 0;
 926 }
 927
 928 static int st_lsm6dsx_set_full_scale(struct st_lsm6dsx_sensor *sensor,
 929                                      u32 gain)
 930 {
 931         const struct st_lsm6dsx_fs_table_entry *fs_table;
 932         unsigned int data;
 933         int i, err;
 934
 935         fs_table = &sensor->hw->settings->fs_table[sensor->id];
 936         for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++)
 937                 if (fs_table->fs_avl[i].gain == gain)
 938                         break;
 939
 940         if (i == ST_LSM6DSX_FS_LIST_SIZE)
 941                 return -EINVAL;
 942
 943         data = ST_LSM6DSX_SHIFT_VAL(fs_table->fs_avl[i].val,
 944                                     fs_table->reg.mask);
 945         err = st_lsm6dsx_update_bits_locked(sensor->hw, fs_table->reg.addr,
 946                                             fs_table->reg.mask, data);
 947         if (err < 0)
 948                 return err;
 949
 950         sensor->gain = gain;
 951
 952         return 0;
 953 }
 954
 955 int st_lsm6dsx_check_odr(struct st_lsm6dsx_sensor *sensor, u16 odr, u8 *val)
 956 {
 957         const struct st_lsm6dsx_odr_table_entry *odr_table;
 958         int i;
 959
 960         odr_table = &sensor->hw->settings->odr_table[sensor->id];
 961         for (i = 0; i < ST_LSM6DSX_ODR_LIST_SIZE; i++)
 962                 /*
 963                  * ext devices can run at different odr respect to
 964                  * accel sensor
 965                  */
 966                 if (odr_table->odr_avl[i].hz >= odr)
 967                         break;
 968
 969         if (i == ST_LSM6DSX_ODR_LIST_SIZE)
 970                 return -EINVAL;
 971
 972         *val = odr_table->odr_avl[i].val;
 973
 974         return 0;
 975 }
 976
 977 static u16 st_lsm6dsx_check_odr_dependency(struct st_lsm6dsx_hw *hw, u16 odr,
 978                                            enum st_lsm6dsx_sensor_id id)
 979 {
 980         struct st_lsm6dsx_sensor *ref = iio_priv(hw->iio_devs[id]);
 981
 982         if (odr > 0) {
 983                 if (hw->enable_mask & BIT(id))
 984                         return max_t(u16, ref->odr, odr);
 985                 else
 986                         return odr;
 987         } else {
 988                 return (hw->enable_mask & BIT(id)) ? ref->odr : 0;
 989         }
 990 }
 991
 992 static int st_lsm6dsx_set_odr(struct st_lsm6dsx_sensor *sensor, u16 req_odr)
 993 {
 994         struct st_lsm6dsx_sensor *ref_sensor = sensor;
 995         struct st_lsm6dsx_hw *hw = sensor->hw;
 996         const struct st_lsm6dsx_reg *reg;
 997         unsigned int data;
 998         u8 val = 0;
 999         int err;
1000
1001         switch (sensor->id) {
1002         case ST_LSM6DSX_ID_EXT0:
1003         case ST_LSM6DSX_ID_EXT1:
1004         case ST_LSM6DSX_ID_EXT2:
1005         case ST_LSM6DSX_ID_ACC: {
1006                 u16 odr;
1007                 int i;
1008
1009                 /*
1010                  * i2c embedded controller relies on the accelerometer sensor as
1011                  * bus read/write trigger so we need to enable accel device
1012                  * at odr = max(accel_odr, ext_odr) in order to properly
1013                  * communicate with i2c slave devices
1014                  */
1015                 ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
1016                 for (i = ST_LSM6DSX_ID_ACC; i < ST_LSM6DSX_ID_MAX; i++) {
1017                         if (!hw->iio_devs[i] || i == sensor->id)
1018                                 continue;
1019
1020                         odr = st_lsm6dsx_check_odr_dependency(hw, req_odr, i);
1021                         if (odr != req_odr)
1022                                 /* device already configured */
1023                                 return 0;
1024                 }
1025                 break;
1026         }
1027         default:
1028                 break;
1029         }
1030
1031         if (req_odr > 0) {
1032                 err = st_lsm6dsx_check_odr(ref_sensor, req_odr, &val);
1033                 if (err < 0)
1034                         return err;
1035         }
1036
1037         reg = &hw->settings->odr_table[ref_sensor->id].reg;
1038         data = ST_LSM6DSX_SHIFT_VAL(val, reg->mask);
1039         return st_lsm6dsx_update_bits_locked(hw, reg->addr, reg->mask, data);
1040 }
1041
1042 int st_lsm6dsx_sensor_set_enable(struct st_lsm6dsx_sensor *sensor,
1043                                  bool enable)
1044 {
1045         struct st_lsm6dsx_hw *hw = sensor->hw;
1046         u16 odr = enable ? sensor->odr : 0;
1047         int err;
1048
1049         err = st_lsm6dsx_set_odr(sensor, odr);
1050         if (err < 0)
1051                 return err;
1052
1053         if (enable)
1054                 hw->enable_mask |= BIT(sensor->id);
1055         else
1056                 hw->enable_mask &= ~BIT(sensor->id);
1057
1058         return 0;
1059 }
1060
1061 static int st_lsm6dsx_read_oneshot(struct st_lsm6dsx_sensor *sensor,
1062                                    u8 addr, int *val)
1063 {
1064         struct st_lsm6dsx_hw *hw = sensor->hw;
1065         int err, delay;
1066         __le16 data;
1067
1068         err = st_lsm6dsx_sensor_set_enable(sensor, true);
1069         if (err < 0)
1070                 return err;
1071
1072         delay = 1000000 / sensor->odr;
1073         usleep_range(delay, 2 * delay);
1074
1075         err = st_lsm6dsx_read_locked(hw, addr, &data, sizeof(data));
1076         if (err < 0)
1077                 return err;
1078
1079         st_lsm6dsx_sensor_set_enable(sensor, false);
1080
1081         *val = (s16)le16_to_cpu(data);
1082
1083         return IIO_VAL_INT;
1084 }
1085
1086 static int st_lsm6dsx_read_raw(struct iio_dev *iio_dev,
1087                                struct iio_chan_spec const *ch,
1088                                int *val, int *val2, long mask)
1089 {
1090         struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
1091         int ret;
1092
1093         switch (mask) {
1094         case IIO_CHAN_INFO_RAW:
1095                 ret = iio_device_claim_direct_mode(iio_dev);
1096                 if (ret)
1097                         break;
1098
1099                 ret = st_lsm6dsx_read_oneshot(sensor, ch->address, val);
1100                 iio_device_release_direct_mode(iio_dev);
1101                 break;
1102         case IIO_CHAN_INFO_SAMP_FREQ:
1103                 *val = sensor->odr;
1104                 ret = IIO_VAL_INT;
1105                 break;
1106         case IIO_CHAN_INFO_SCALE:
1107                 *val = 0;
1108                 *val2 = sensor->gain;
1109                 ret = IIO_VAL_INT_PLUS_MICRO;
1110                 break;
1111         default:
1112                 ret = -EINVAL;
1113                 break;
1114         }
1115
1116         return ret;
1117 }
1118
1119 static int st_lsm6dsx_write_raw(struct iio_dev *iio_dev,
1120                                 struct iio_chan_spec const *chan,
1121                                 int val, int val2, long mask)
1122 {
1123         struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
1124         int err;
1125
1126         err = iio_device_claim_direct_mode(iio_dev);
1127         if (err)
1128                 return err;
1129
1130         switch (mask) {
1131         case IIO_CHAN_INFO_SCALE:
1132                 err = st_lsm6dsx_set_full_scale(sensor, val2);
1133                 break;
1134         case IIO_CHAN_INFO_SAMP_FREQ: {
1135                 u8 data;
1136
1137                 err = st_lsm6dsx_check_odr(sensor, val, &data);
1138                 if (!err)
1139                         sensor->odr = val;
1140                 break;
1141         }
1142         default:
1143                 err = -EINVAL;
1144                 break;
1145         }
1146
1147         iio_device_release_direct_mode(iio_dev);
1148
1149         return err;
1150 }
1151
1152 int st_lsm6dsx_set_watermark(struct iio_dev *iio_dev, unsigned int val)
1153 {
1154         struct st_lsm6dsx_sensor *sensor = iio_priv(iio_dev);
1155         struct st_lsm6dsx_hw *hw = sensor->hw;
1156         int err;
1157
1158         if (val < 1 || val > hw->settings->max_fifo_size)
1159                 return -EINVAL;
1160
1161         mutex_lock(&hw->conf_lock);
1162
1163         err = st_lsm6dsx_update_watermark(sensor, val);
1164
1165         mutex_unlock(&hw->conf_lock);
1166
1167         if (err < 0)
1168                 return err;
1169
1170         sensor->watermark = val;
1171
1172         return 0;
1173 }
1174
1175 static ssize_t
1176 st_lsm6dsx_sysfs_sampling_frequency_avail(struct device *dev,
1177                                           struct device_attribute *attr,
1178                                           char *buf)
1179 {
1180         struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
1181         enum st_lsm6dsx_sensor_id id = sensor->id;
1182         struct st_lsm6dsx_hw *hw = sensor->hw;
1183         int i, len = 0;
1184
1185         for (i = 0; i < ST_LSM6DSX_ODR_LIST_SIZE; i++)
1186                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
1187                                  hw->settings->odr_table[id].odr_avl[i].hz);
1188         buf[len - 1] = '\n';
1189
1190         return len;
1191 }
1192
1193 static ssize_t st_lsm6dsx_sysfs_scale_avail(struct device *dev,
1194                                             struct device_attribute *attr,
1195                                             char *buf)
1196 {
1197         struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
1198         const struct st_lsm6dsx_fs_table_entry *fs_table;
1199         enum st_lsm6dsx_sensor_id id = sensor->id;
1200         struct st_lsm6dsx_hw *hw = sensor->hw;
1201         int i, len = 0;
1202
1203         fs_table = &hw->settings->fs_table[id];
1204         for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++) {
1205                 if (!fs_table->fs_avl[i].gain)
1206                         break;
1207
1208                 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
1209                                  fs_table->fs_avl[i].gain);
1210         }
1211         buf[len - 1] = '\n';
1212
1213         return len;
1214 }
1215
1216 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(st_lsm6dsx_sysfs_sampling_frequency_avail);
1217 static IIO_DEVICE_ATTR(in_accel_scale_available, 0444,
1218                        st_lsm6dsx_sysfs_scale_avail, NULL, 0);
1219 static IIO_DEVICE_ATTR(in_anglvel_scale_available, 0444,
1220                        st_lsm6dsx_sysfs_scale_avail, NULL, 0);
1221
1222 static struct attribute *st_lsm6dsx_acc_attributes[] = {
1223         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1224         &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
1225         NULL,
1226 };
1227
1228 static const struct attribute_group st_lsm6dsx_acc_attribute_group = {
1229         .attrs = st_lsm6dsx_acc_attributes,
1230 };
1231
1232 static const struct iio_info st_lsm6dsx_acc_info = {
1233         .attrs = &st_lsm6dsx_acc_attribute_group,
1234         .read_raw = st_lsm6dsx_read_raw,
1235         .write_raw = st_lsm6dsx_write_raw,
1236         .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
1237 };
1238
1239 static struct attribute *st_lsm6dsx_gyro_attributes[] = {
1240         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1241         &iio_dev_attr_in_anglvel_scale_available.dev_attr.attr,
1242         NULL,
1243 };
1244
1245 static const struct attribute_group st_lsm6dsx_gyro_attribute_group = {
1246         .attrs = st_lsm6dsx_gyro_attributes,
1247 };
1248
1249 static const struct iio_info st_lsm6dsx_gyro_info = {
1250         .attrs = &st_lsm6dsx_gyro_attribute_group,
1251         .read_raw = st_lsm6dsx_read_raw,
1252         .write_raw = st_lsm6dsx_write_raw,
1253         .hwfifo_set_watermark = st_lsm6dsx_set_watermark,
1254 };
1255
1256 static int st_lsm6dsx_of_get_drdy_pin(struct st_lsm6dsx_hw *hw, int *drdy_pin)
1257 {
1258         struct device_node *np = hw->dev->of_node;
1259
1260         if (!np)
1261                 return -EINVAL;
1262
1263         return of_property_read_u32(np, "st,drdy-int-pin", drdy_pin);
1264 }
1265
1266 static int st_lsm6dsx_get_drdy_reg(struct st_lsm6dsx_hw *hw, u8 *drdy_reg)
1267 {
1268         int err = 0, drdy_pin;
1269
1270         if (st_lsm6dsx_of_get_drdy_pin(hw, &drdy_pin) < 0) {
1271                 struct st_sensors_platform_data *pdata;
1272                 struct device *dev = hw->dev;
1273
1274                 pdata = (struct st_sensors_platform_data *)dev->platform_data;
1275                 drdy_pin = pdata ? pdata->drdy_int_pin : 1;
1276         }
1277
1278         switch (drdy_pin) {
1279         case 1:
1280                 *drdy_reg = hw->settings->int1_addr;
1281                 break;
1282         case 2:
1283                 *drdy_reg = hw->settings->int2_addr;
1284                 break;
1285         default:
1286                 dev_err(hw->dev, "unsupported data ready pin\n");
1287                 err = -EINVAL;
1288                 break;
1289         }
1290
1291         return err;
1292 }
1293
1294 static int st_lsm6dsx_init_shub(struct st_lsm6dsx_hw *hw)
1295 {
1296         const struct st_lsm6dsx_shub_settings *hub_settings;
1297         struct device_node *np = hw->dev->of_node;
1298         struct st_sensors_platform_data *pdata;
1299         unsigned int data;
1300         int err = 0;
1301
1302         hub_settings = &hw->settings->shub_settings;
1303
1304         pdata = (struct st_sensors_platform_data *)hw->dev->platform_data;
1305         if ((np && of_property_read_bool(np, "st,pullups")) ||
1306             (pdata && pdata->pullups)) {
1307                 err = st_lsm6dsx_set_page(hw, true);
1308                 if (err < 0)
1309                         return err;
1310
1311                 data = ST_LSM6DSX_SHIFT_VAL(1, hub_settings->pullup_en.mask);
1312                 err = regmap_update_bits(hw->regmap,
1313                                          hub_settings->pullup_en.addr,
1314                                          hub_settings->pullup_en.mask, data);
1315
1316                 st_lsm6dsx_set_page(hw, false);
1317
1318                 if (err < 0)
1319                         return err;
1320         }
1321
1322         if (hub_settings->aux_sens.addr) {
1323                 /* configure aux sensors */
1324                 err = st_lsm6dsx_set_page(hw, true);
1325                 if (err < 0)
1326                         return err;
1327
1328                 data = ST_LSM6DSX_SHIFT_VAL(3, hub_settings->aux_sens.mask);
1329                 err = regmap_update_bits(hw->regmap,
1330                                          hub_settings->aux_sens.addr,
1331                                          hub_settings->aux_sens.mask, data);
1332
1333                 st_lsm6dsx_set_page(hw, false);
1334         }
1335
1336         return err;
1337 }
1338
1339 static int st_lsm6dsx_init_hw_timer(struct st_lsm6dsx_hw *hw)
1340 {
1341         const struct st_lsm6dsx_hw_ts_settings *ts_settings;
1342         int err, val;
1343
1344         ts_settings = &hw->settings->ts_settings;
1345         /* enable hw timestamp generation if necessary */
1346         if (ts_settings->timer_en.addr) {
1347                 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->timer_en.mask);
1348                 err = regmap_update_bits(hw->regmap,
1349                                          ts_settings->timer_en.addr,
1350                                          ts_settings->timer_en.mask, val);
1351                 if (err < 0)
1352                         return err;
1353         }
1354
1355         /* enable high resolution for hw ts timer if necessary */
1356         if (ts_settings->hr_timer.addr) {
1357                 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->hr_timer.mask);
1358                 err = regmap_update_bits(hw->regmap,
1359                                          ts_settings->hr_timer.addr,
1360                                          ts_settings->hr_timer.mask, val);
1361                 if (err < 0)
1362                         return err;
1363         }
1364
1365         /* enable ts queueing in FIFO if necessary */
1366         if (ts_settings->fifo_en.addr) {
1367                 val = ST_LSM6DSX_SHIFT_VAL(1, ts_settings->fifo_en.mask);
1368                 err = regmap_update_bits(hw->regmap,
1369                                          ts_settings->fifo_en.addr,
1370                                          ts_settings->fifo_en.mask, val);
1371                 if (err < 0)
1372                         return err;
1373         }
1374         return 0;
1375 }
1376
1377 static int st_lsm6dsx_init_device(struct st_lsm6dsx_hw *hw)
1378 {
1379         u8 drdy_int_reg;
1380         int err;
1381
1382         /* device sw reset */
1383         err = regmap_update_bits(hw->regmap, hw->settings->reset_addr,
1384                                  ST_LSM6DSX_REG_RESET_MASK,
1385                                  FIELD_PREP(ST_LSM6DSX_REG_RESET_MASK, 1));
1386         if (err < 0)
1387                 return err;
1388
1389         msleep(50);
1390
1391         /* reload trimming parameter */
1392         err = regmap_update_bits(hw->regmap, hw->settings->reset_addr,
1393                                  ST_LSM6DSX_REG_BOOT_MASK,
1394                                  FIELD_PREP(ST_LSM6DSX_REG_BOOT_MASK, 1));
1395         if (err < 0)
1396                 return err;
1397
1398         msleep(50);
1399
1400         /* enable Block Data Update */
1401         err = regmap_update_bits(hw->regmap, ST_LSM6DSX_REG_BDU_ADDR,
1402                                  ST_LSM6DSX_REG_BDU_MASK,
1403                                  FIELD_PREP(ST_LSM6DSX_REG_BDU_MASK, 1));
1404         if (err < 0)
1405                 return err;
1406
1407         /* enable FIFO watermak interrupt */
1408         err = st_lsm6dsx_get_drdy_reg(hw, &drdy_int_reg);
1409         if (err < 0)
1410                 return err;
1411
1412         err = regmap_update_bits(hw->regmap, drdy_int_reg,
1413                                  ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK,
1414                                  FIELD_PREP(ST_LSM6DSX_REG_FIFO_FTH_IRQ_MASK,
1415                                             1));
1416         if (err < 0)
1417                 return err;
1418
1419         err = st_lsm6dsx_init_shub(hw);
1420         if (err < 0)
1421                 return err;
1422
1423         return st_lsm6dsx_init_hw_timer(hw);
1424 }
1425
1426 static struct iio_dev *st_lsm6dsx_alloc_iiodev(struct st_lsm6dsx_hw *hw,
1427                                                enum st_lsm6dsx_sensor_id id,
1428                                                const char *name)
1429 {
1430         struct st_lsm6dsx_sensor *sensor;
1431         struct iio_dev *iio_dev;
1432
1433         iio_dev = devm_iio_device_alloc(hw->dev, sizeof(*sensor));
1434         if (!iio_dev)
1435                 return NULL;
1436
1437         iio_dev->modes = INDIO_DIRECT_MODE;
1438         iio_dev->dev.parent = hw->dev;
1439         iio_dev->available_scan_masks = st_lsm6dsx_available_scan_masks;
1440         iio_dev->channels = hw->settings->channels[id].chan;
1441         iio_dev->num_channels = hw->settings->channels[id].len;
1442
1443         sensor = iio_priv(iio_dev);
1444         sensor->id = id;
1445         sensor->hw = hw;
1446         sensor->odr = hw->settings->odr_table[id].odr_avl[0].hz;
1447         sensor->gain = hw->settings->fs_table[id].fs_avl[0].gain;
1448         sensor->watermark = 1;
1449
1450         switch (id) {
1451         case ST_LSM6DSX_ID_ACC:
1452                 iio_dev->info = &st_lsm6dsx_acc_info;
1453                 scnprintf(sensor->name, sizeof(sensor->name), "%s_accel",
1454                           name);
1455                 break;
1456         case ST_LSM6DSX_ID_GYRO:
1457                 iio_dev->info = &st_lsm6dsx_gyro_info;
1458                 scnprintf(sensor->name, sizeof(sensor->name), "%s_gyro",
1459                           name);
1460                 break;
1461         default:
1462                 return NULL;
1463         }
1464         iio_dev->name = sensor->name;
1465
1466         return iio_dev;
1467 }
1468
1469 int st_lsm6dsx_probe(struct device *dev, int irq, int hw_id,
1470                      struct regmap *regmap)
1471 {
1472         const struct st_lsm6dsx_shub_settings *hub_settings;
1473         struct st_lsm6dsx_hw *hw;
1474         const char *name = NULL;
1475         int i, err;
1476
1477         hw = devm_kzalloc(dev, sizeof(*hw), GFP_KERNEL);
1478         if (!hw)
1479                 return -ENOMEM;
1480
1481         dev_set_drvdata(dev, (void *)hw);
1482
1483         mutex_init(&hw->fifo_lock);
1484         mutex_init(&hw->conf_lock);
1485         mutex_init(&hw->page_lock);
1486
1487         hw->buff = devm_kzalloc(dev, ST_LSM6DSX_BUFF_SIZE, GFP_KERNEL);
1488         if (!hw->buff)
1489                 return -ENOMEM;
1490
1491         hw->dev = dev;
1492         hw->irq = irq;
1493         hw->regmap = regmap;
1494
1495         err = st_lsm6dsx_check_whoami(hw, hw_id, &name);
1496         if (err < 0)
1497                 return err;
1498
1499         for (i = 0; i < ST_LSM6DSX_ID_EXT0; i++) {
1500                 hw->iio_devs[i] = st_lsm6dsx_alloc_iiodev(hw, i, name);
1501                 if (!hw->iio_devs[i])
1502                         return -ENOMEM;
1503         }
1504
1505         err = st_lsm6dsx_init_device(hw);
1506         if (err < 0)
1507                 return err;
1508
1509         hub_settings = &hw->settings->shub_settings;
1510         if (hub_settings->master_en.addr) {
1511                 err = st_lsm6dsx_shub_probe(hw, name);
1512                 if (err < 0)
1513                         return err;
1514         }
1515
1516         if (hw->irq > 0) {
1517                 err = st_lsm6dsx_fifo_setup(hw);
1518                 if (err < 0)
1519                         return err;
1520         }
1521
1522         for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) {
1523                 if (!hw->iio_devs[i])
1524                         continue;
1525
1526                 err = devm_iio_device_register(hw->dev, hw->iio_devs[i]);
1527                 if (err)
1528                         return err;
1529         }
1530
1531         return 0;
1532 }
1533 EXPORT_SYMBOL(st_lsm6dsx_probe);
1534
1535 static int __maybe_unused st_lsm6dsx_suspend(struct device *dev)
1536 {
1537         struct st_lsm6dsx_hw *hw = dev_get_drvdata(dev);
1538         struct st_lsm6dsx_sensor *sensor;
1539         int i, err = 0;
1540
1541         for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) {
1542                 if (!hw->iio_devs[i])
1543                         continue;
1544
1545                 sensor = iio_priv(hw->iio_devs[i]);
1546                 if (!(hw->enable_mask & BIT(sensor->id)))
1547                         continue;
1548
1549                 if (sensor->id == ST_LSM6DSX_ID_EXT0 ||
1550                     sensor->id == ST_LSM6DSX_ID_EXT1 ||
1551                     sensor->id == ST_LSM6DSX_ID_EXT2)
1552                         err = st_lsm6dsx_shub_set_enable(sensor, false);
1553                 else
1554                         err = st_lsm6dsx_sensor_set_enable(sensor, false);
1555                 if (err < 0)
1556                         return err;
1557
1558                 hw->suspend_mask |= BIT(sensor->id);
1559         }
1560
1561         if (hw->fifo_mode != ST_LSM6DSX_FIFO_BYPASS)
1562                 err = st_lsm6dsx_flush_fifo(hw);
1563
1564         return err;
1565 }
1566
1567 static int __maybe_unused st_lsm6dsx_resume(struct device *dev)
1568 {
1569         struct st_lsm6dsx_hw *hw = dev_get_drvdata(dev);
1570         struct st_lsm6dsx_sensor *sensor;
1571         int i, err = 0;
1572
1573         for (i = 0; i < ST_LSM6DSX_ID_MAX; i++) {
1574                 if (!hw->iio_devs[i])
1575                         continue;
1576
1577                 sensor = iio_priv(hw->iio_devs[i]);
1578                 if (!(hw->suspend_mask & BIT(sensor->id)))
1579                         continue;
1580
1581                 if (sensor->id == ST_LSM6DSX_ID_EXT0 ||
1582                     sensor->id == ST_LSM6DSX_ID_EXT1 ||
1583                     sensor->id == ST_LSM6DSX_ID_EXT2)
1584                         err = st_lsm6dsx_shub_set_enable(sensor, true);
1585                 else
1586                         err = st_lsm6dsx_sensor_set_enable(sensor, true);
1587                 if (err < 0)
1588                         return err;
1589
1590                 hw->suspend_mask &= ~BIT(sensor->id);
1591         }
1592
1593         if (hw->enable_mask)
1594                 err = st_lsm6dsx_set_fifo_mode(hw, ST_LSM6DSX_FIFO_CONT);
1595
1596         return err;
1597 }
1598
1599 const struct dev_pm_ops st_lsm6dsx_pm_ops = {
1600         SET_SYSTEM_SLEEP_PM_OPS(st_lsm6dsx_suspend, st_lsm6dsx_resume)
1601 };
1602 EXPORT_SYMBOL(st_lsm6dsx_pm_ops);
1603
1604 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
1605 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
1606 MODULE_DESCRIPTION("STMicroelectronics st_lsm6dsx driver");
1607 MODULE_LICENSE("GPL v2");