drivers/iio/accel/st_accel_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * STMicroelectronics accelerometers driver
   4  *
   5  * Copyright 2012-2013 STMicroelectronics Inc.
   6  *
   7  * Denis Ciocca <denis.ciocca@st.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/acpi.h>
  14 #include <linux/errno.h>
  15 #include <linux/types.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/i2c.h>
  18 #include <linux/irq.h>
  19 #include <linux/iio/iio.h>
  20 #include <linux/iio/sysfs.h>
  21 #include <linux/iio/trigger.h>
  22 #include <linux/iio/buffer.h>
  23
  24 #include <linux/iio/common/st_sensors.h>
  25 #include "st_accel.h"
  26
  27 #define ST_ACCEL_NUMBER_DATA_CHANNELS           3
  28
  29 /* DEFAULT VALUE FOR SENSORS */
  30 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR           0x28
  31 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR           0x2a
  32 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR           0x2c
  33
  34 /* FULLSCALE */
  35 #define ST_ACCEL_FS_AVL_2G                      2
  36 #define ST_ACCEL_FS_AVL_4G                      4
  37 #define ST_ACCEL_FS_AVL_6G                      6
  38 #define ST_ACCEL_FS_AVL_8G                      8
  39 #define ST_ACCEL_FS_AVL_16G                     16
  40 #define ST_ACCEL_FS_AVL_100G                    100
  41 #define ST_ACCEL_FS_AVL_200G                    200
  42 #define ST_ACCEL_FS_AVL_400G                    400
  43
  44 static const struct iio_mount_matrix *
  45 st_accel_get_mount_matrix(const struct iio_dev *indio_dev,
  46                           const struct iio_chan_spec *chan)
  47 {
  48         struct st_sensor_data *adata = iio_priv(indio_dev);
  49
  50         return &adata->mount_matrix;
  51 }
  52
  53 static const struct iio_chan_spec_ext_info st_accel_mount_matrix_ext_info[] = {
  54         IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_accel_get_mount_matrix),
  55         { }
  56 };
  57
  58 static const struct iio_chan_spec st_accel_8bit_channels[] = {
  59         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  60                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  61                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
  62                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1,
  63                         st_accel_mount_matrix_ext_info),
  64         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  65                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  66                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
  67                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1,
  68                         st_accel_mount_matrix_ext_info),
  69         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  70                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  71                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
  72                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1,
  73                         st_accel_mount_matrix_ext_info),
  74         IIO_CHAN_SOFT_TIMESTAMP(3)
  75 };
  76
  77 static const struct iio_chan_spec st_accel_12bit_channels[] = {
  78         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  79                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  80                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
  81                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
  82                         st_accel_mount_matrix_ext_info),
  83         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  84                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  85                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
  86                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
  87                         st_accel_mount_matrix_ext_info),
  88         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  89                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  90                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
  91                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
  92                         st_accel_mount_matrix_ext_info),
  93         IIO_CHAN_SOFT_TIMESTAMP(3)
  94 };
  95
  96 static const struct iio_chan_spec st_accel_16bit_channels[] = {
  97         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
  98                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  99                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
 100                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
 101                         st_accel_mount_matrix_ext_info),
 102         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 103                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 104                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
 105                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
 106                         st_accel_mount_matrix_ext_info),
 107         ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
 108                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 109                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
 110                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
 111                         st_accel_mount_matrix_ext_info),
 112         IIO_CHAN_SOFT_TIMESTAMP(3)
 113 };
 114
 115 static const struct st_sensor_settings st_accel_sensors_settings[] = {
 116         {
 117                 .wai = 0x33,
 118                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 119                 .sensors_supported = {
 120                         [0] = LIS3DH_ACCEL_DEV_NAME,
 121                         [1] = LSM303DLHC_ACCEL_DEV_NAME,
 122                         [2] = LSM330D_ACCEL_DEV_NAME,
 123                         [3] = LSM330DL_ACCEL_DEV_NAME,
 124                         [4] = LSM330DLC_ACCEL_DEV_NAME,
 125                         [5] = LSM303AGR_ACCEL_DEV_NAME,
 126                         [6] = LIS2DH12_ACCEL_DEV_NAME,
 127                         [7] = LIS3DE_ACCEL_DEV_NAME,
 128                 },
 129                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 130                 .odr = {
 131                         .addr = 0x20,
 132                         .mask = 0xf0,
 133                         .odr_avl = {
 134                                 { .hz = 1, .value = 0x01, },
 135                                 { .hz = 10, .value = 0x02, },
 136                                 { .hz = 25, .value = 0x03, },
 137                                 { .hz = 50, .value = 0x04, },
 138                                 { .hz = 100, .value = 0x05, },
 139                                 { .hz = 200, .value = 0x06, },
 140                                 { .hz = 400, .value = 0x07, },
 141                                 { .hz = 1600, .value = 0x08, },
 142                         },
 143                 },
 144                 .pw = {
 145                         .addr = 0x20,
 146                         .mask = 0xf0,
 147                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 148                 },
 149                 .enable_axis = {
 150                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 151                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 152                 },
 153                 .fs = {
 154                         .addr = 0x23,
 155                         .mask = 0x30,
 156                         .fs_avl = {
 157                                 [0] = {
 158                                         .num = ST_ACCEL_FS_AVL_2G,
 159                                         .value = 0x00,
 160                                         .gain = IIO_G_TO_M_S_2(1000),
 161                                 },
 162                                 [1] = {
 163                                         .num = ST_ACCEL_FS_AVL_4G,
 164                                         .value = 0x01,
 165                                         .gain = IIO_G_TO_M_S_2(2000),
 166                                 },
 167                                 [2] = {
 168                                         .num = ST_ACCEL_FS_AVL_8G,
 169                                         .value = 0x02,
 170                                         .gain = IIO_G_TO_M_S_2(4000),
 171                                 },
 172                                 [3] = {
 173                                         .num = ST_ACCEL_FS_AVL_16G,
 174                                         .value = 0x03,
 175                                         .gain = IIO_G_TO_M_S_2(12000),
 176                                 },
 177                         },
 178                 },
 179                 .bdu = {
 180                         .addr = 0x23,
 181                         .mask = 0x80,
 182                 },
 183                 .drdy_irq = {
 184                         .int1 = {
 185                                 .addr = 0x22,
 186                                 .mask = 0x10,
 187                         },
 188                         .addr_ihl = 0x25,
 189                         .mask_ihl = 0x02,
 190                         .stat_drdy = {
 191                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 192                                 .mask = 0x07,
 193                         },
 194                 },
 195                 .sim = {
 196                         .addr = 0x23,
 197                         .value = BIT(0),
 198                 },
 199                 .multi_read_bit = true,
 200                 .bootime = 2,
 201         },
 202         {
 203                 .wai = 0x32,
 204                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 205                 .sensors_supported = {
 206                         [0] = LIS331DLH_ACCEL_DEV_NAME,
 207                         [1] = LSM303DL_ACCEL_DEV_NAME,
 208                         [2] = LSM303DLH_ACCEL_DEV_NAME,
 209                         [3] = LSM303DLM_ACCEL_DEV_NAME,
 210                 },
 211                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 212                 .odr = {
 213                         .addr = 0x20,
 214                         .mask = 0x18,
 215                         .odr_avl = {
 216                                 { .hz = 50, .value = 0x00, },
 217                                 { .hz = 100, .value = 0x01, },
 218                                 { .hz = 400, .value = 0x02, },
 219                                 { .hz = 1000, .value = 0x03, },
 220                         },
 221                 },
 222                 .pw = {
 223                         .addr = 0x20,
 224                         .mask = 0xe0,
 225                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 226                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 227                 },
 228                 .enable_axis = {
 229                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 230                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 231                 },
 232                 .fs = {
 233                         .addr = 0x23,
 234                         .mask = 0x30,
 235                         .fs_avl = {
 236                                 [0] = {
 237                                         .num = ST_ACCEL_FS_AVL_2G,
 238                                         .value = 0x00,
 239                                         .gain = IIO_G_TO_M_S_2(1000),
 240                                 },
 241                                 [1] = {
 242                                         .num = ST_ACCEL_FS_AVL_4G,
 243                                         .value = 0x01,
 244                                         .gain = IIO_G_TO_M_S_2(2000),
 245                                 },
 246                                 [2] = {
 247                                         .num = ST_ACCEL_FS_AVL_8G,
 248                                         .value = 0x03,
 249                                         .gain = IIO_G_TO_M_S_2(3900),
 250                                 },
 251                         },
 252                 },
 253                 .bdu = {
 254                         .addr = 0x23,
 255                         .mask = 0x80,
 256                 },
 257                 .drdy_irq = {
 258                         .int1 = {
 259                                 .addr = 0x22,
 260                                 .mask = 0x02,
 261                                 .addr_od = 0x22,
 262                                 .mask_od = 0x40,
 263                         },
 264                         .int2 = {
 265                                 .addr = 0x22,
 266                                 .mask = 0x10,
 267                                 .addr_od = 0x22,
 268                                 .mask_od = 0x40,
 269                         },
 270                         .addr_ihl = 0x22,
 271                         .mask_ihl = 0x80,
 272                         .stat_drdy = {
 273                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 274                                 .mask = 0x07,
 275                         },
 276                 },
 277                 .sim = {
 278                         .addr = 0x23,
 279                         .value = BIT(0),
 280                 },
 281                 .multi_read_bit = true,
 282                 .bootime = 2,
 283         },
 284         {
 285                 .wai = 0x40,
 286                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 287                 .sensors_supported = {
 288                         [0] = LSM330_ACCEL_DEV_NAME,
 289                 },
 290                 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
 291                 .odr = {
 292                         .addr = 0x20,
 293                         .mask = 0xf0,
 294                         .odr_avl = {
 295                                 { .hz = 3, .value = 0x01, },
 296                                 { .hz = 6, .value = 0x02, },
 297                                 { .hz = 12, .value = 0x03, },
 298                                 { .hz = 25, .value = 0x04, },
 299                                 { .hz = 50, .value = 0x05, },
 300                                 { .hz = 100, .value = 0x06, },
 301                                 { .hz = 200, .value = 0x07, },
 302                                 { .hz = 400, .value = 0x08, },
 303                                 { .hz = 800, .value = 0x09, },
 304                                 { .hz = 1600, .value = 0x0a, },
 305                         },
 306                 },
 307                 .pw = {
 308                         .addr = 0x20,
 309                         .mask = 0xf0,
 310                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 311                 },
 312                 .enable_axis = {
 313                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 314                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 315                 },
 316                 .fs = {
 317                         .addr = 0x24,
 318                         .mask = 0x38,
 319                         .fs_avl = {
 320                                 [0] = {
 321                                         .num = ST_ACCEL_FS_AVL_2G,
 322                                         .value = 0x00,
 323                                         .gain = IIO_G_TO_M_S_2(61),
 324                                 },
 325                                 [1] = {
 326                                         .num = ST_ACCEL_FS_AVL_4G,
 327                                         .value = 0x01,
 328                                         .gain = IIO_G_TO_M_S_2(122),
 329                                 },
 330                                 [2] = {
 331                                         .num = ST_ACCEL_FS_AVL_6G,
 332                                         .value = 0x02,
 333                                         .gain = IIO_G_TO_M_S_2(183),
 334                                 },
 335                                 [3] = {
 336                                         .num = ST_ACCEL_FS_AVL_8G,
 337                                         .value = 0x03,
 338                                         .gain = IIO_G_TO_M_S_2(244),
 339                                 },
 340                                 [4] = {
 341                                         .num = ST_ACCEL_FS_AVL_16G,
 342                                         .value = 0x04,
 343                                         .gain = IIO_G_TO_M_S_2(732),
 344                                 },
 345                         },
 346                 },
 347                 .bdu = {
 348                         .addr = 0x20,
 349                         .mask = 0x08,
 350                 },
 351                 .drdy_irq = {
 352                         .int1 = {
 353                                 .addr = 0x23,
 354                                 .mask = 0x80,
 355                         },
 356                         .addr_ihl = 0x23,
 357                         .mask_ihl = 0x40,
 358                         .stat_drdy = {
 359                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 360                                 .mask = 0x07,
 361                         },
 362                         .ig1 = {
 363                                 .en_addr = 0x23,
 364                                 .en_mask = 0x08,
 365                         },
 366                 },
 367                 .sim = {
 368                         .addr = 0x24,
 369                         .value = BIT(0),
 370                 },
 371                 .multi_read_bit = false,
 372                 .bootime = 2,
 373         },
 374         {
 375                 .wai = 0x3a,
 376                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 377                 .sensors_supported = {
 378                         [0] = LIS3LV02DL_ACCEL_DEV_NAME,
 379                 },
 380                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 381                 .odr = {
 382                         .addr = 0x20,
 383                         .mask = 0x30, /* DF1 and DF0 */
 384                         .odr_avl = {
 385                                 { .hz = 40, .value = 0x00, },
 386                                 { .hz = 160, .value = 0x01, },
 387                                 { .hz = 640, .value = 0x02, },
 388                                 { .hz = 2560, .value = 0x03, },
 389                         },
 390                 },
 391                 .pw = {
 392                         .addr = 0x20,
 393                         .mask = 0xc0,
 394                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 395                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 396                 },
 397                 .enable_axis = {
 398                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 399                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 400                 },
 401                 .fs = {
 402                         .addr = 0x21,
 403                         .mask = 0x80,
 404                         .fs_avl = {
 405                                 [0] = {
 406                                         .num = ST_ACCEL_FS_AVL_2G,
 407                                         .value = 0x00,
 408                                         .gain = IIO_G_TO_M_S_2(1000),
 409                                 },
 410                                 [1] = {
 411                                         .num = ST_ACCEL_FS_AVL_6G,
 412                                         .value = 0x01,
 413                                         .gain = IIO_G_TO_M_S_2(3000),
 414                                 },
 415                         },
 416                 },
 417                 .bdu = {
 418                         .addr = 0x21,
 419                         .mask = 0x40,
 420                 },
 421                 /*
 422                  * Data Alignment Setting - needs to be set to get
 423                  * left-justified data like all other sensors.
 424                  */
 425                 .das = {
 426                         .addr = 0x21,
 427                         .mask = 0x01,
 428                 },
 429                 .drdy_irq = {
 430                         .int1 = {
 431                                 .addr = 0x21,
 432                                 .mask = 0x04,
 433                         },
 434                         .stat_drdy = {
 435                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 436                                 .mask = 0x07,
 437                         },
 438                 },
 439                 .sim = {
 440                         .addr = 0x21,
 441                         .value = BIT(1),
 442                 },
 443                 .multi_read_bit = true,
 444                 .bootime = 2, /* guess */
 445         },
 446         {
 447                 .wai = 0x3b,
 448                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 449                 .sensors_supported = {
 450                         [0] = LIS331DL_ACCEL_DEV_NAME,
 451                 },
 452                 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
 453                 .odr = {
 454                         .addr = 0x20,
 455                         .mask = 0x80,
 456                         .odr_avl = {
 457                                 { .hz = 100, .value = 0x00, },
 458                                 { .hz = 400, .value = 0x01, },
 459                         },
 460                 },
 461                 .pw = {
 462                         .addr = 0x20,
 463                         .mask = 0x40,
 464                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 465                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 466                 },
 467                 .enable_axis = {
 468                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 469                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 470                 },
 471                 .fs = {
 472                         .addr = 0x20,
 473                         .mask = 0x20,
 474                         /*
 475                          * TODO: check these resulting gain settings, these are
 476                          * not in the datsheet
 477                          */
 478                         .fs_avl = {
 479                                 [0] = {
 480                                         .num = ST_ACCEL_FS_AVL_2G,
 481                                         .value = 0x00,
 482                                         .gain = IIO_G_TO_M_S_2(18000),
 483                                 },
 484                                 [1] = {
 485                                         .num = ST_ACCEL_FS_AVL_8G,
 486                                         .value = 0x01,
 487                                         .gain = IIO_G_TO_M_S_2(72000),
 488                                 },
 489                         },
 490                 },
 491                 .drdy_irq = {
 492                         .int1 = {
 493                                 .addr = 0x22,
 494                                 .mask = 0x04,
 495                                 .addr_od = 0x22,
 496                                 .mask_od = 0x40,
 497                         },
 498                         .int2 = {
 499                                 .addr = 0x22,
 500                                 .mask = 0x20,
 501                                 .addr_od = 0x22,
 502                                 .mask_od = 0x40,
 503                         },
 504                         .addr_ihl = 0x22,
 505                         .mask_ihl = 0x80,
 506                         .stat_drdy = {
 507                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 508                                 .mask = 0x07,
 509                         },
 510                 },
 511                 .sim = {
 512                         .addr = 0x21,
 513                         .value = BIT(7),
 514                 },
 515                 .multi_read_bit = false,
 516                 .bootime = 2, /* guess */
 517         },
 518         {
 519                 .wai = 0x32,
 520                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 521                 .sensors_supported = {
 522                         [0] = H3LIS331DL_ACCEL_DEV_NAME,
 523                 },
 524                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 525                 .odr = {
 526                         .addr = 0x20,
 527                         .mask = 0x18,
 528                         .odr_avl = {
 529                                 { .hz = 50, .value = 0x00, },
 530                                 { .hz = 100, .value = 0x01, },
 531                                 { .hz = 400, .value = 0x02, },
 532                                 { .hz = 1000, .value = 0x03, },
 533                         },
 534                 },
 535                 .pw = {
 536                         .addr = 0x20,
 537                         .mask = 0x20,
 538                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 539                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 540                 },
 541                 .enable_axis = {
 542                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 543                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 544                 },
 545                 .fs = {
 546                         .addr = 0x23,
 547                         .mask = 0x30,
 548                         .fs_avl = {
 549                                 [0] = {
 550                                         .num = ST_ACCEL_FS_AVL_100G,
 551                                         .value = 0x00,
 552                                         .gain = IIO_G_TO_M_S_2(49000),
 553                                 },
 554                                 [1] = {
 555                                         .num = ST_ACCEL_FS_AVL_200G,
 556                                         .value = 0x01,
 557                                         .gain = IIO_G_TO_M_S_2(98000),
 558                                 },
 559                                 [2] = {
 560                                         .num = ST_ACCEL_FS_AVL_400G,
 561                                         .value = 0x03,
 562                                         .gain = IIO_G_TO_M_S_2(195000),
 563                                 },
 564                         },
 565                 },
 566                 .bdu = {
 567                         .addr = 0x23,
 568                         .mask = 0x80,
 569                 },
 570                 .drdy_irq = {
 571                         .int1 = {
 572                                 .addr = 0x22,
 573                                 .mask = 0x02,
 574                         },
 575                         .int2 = {
 576                                 .addr = 0x22,
 577                                 .mask = 0x10,
 578                         },
 579                         .addr_ihl = 0x22,
 580                         .mask_ihl = 0x80,
 581                 },
 582                 .sim = {
 583                         .addr = 0x23,
 584                         .value = BIT(0),
 585                 },
 586                 .multi_read_bit = true,
 587                 .bootime = 2,
 588         },
 589         {
 590                 /* No WAI register present */
 591                 .sensors_supported = {
 592                         [0] = LIS3L02DQ_ACCEL_DEV_NAME,
 593                 },
 594                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 595                 .odr = {
 596                         .addr = 0x20,
 597                         .mask = 0x30,
 598                         .odr_avl = {
 599                                 { .hz = 280, .value = 0x00, },
 600                                 { .hz = 560, .value = 0x01, },
 601                                 { .hz = 1120, .value = 0x02, },
 602                                 { .hz = 4480, .value = 0x03, },
 603                         },
 604                 },
 605                 .pw = {
 606                         .addr = 0x20,
 607                         .mask = 0xc0,
 608                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 609                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 610                 },
 611                 .enable_axis = {
 612                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 613                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 614                 },
 615                 .fs = {
 616                         .fs_avl = {
 617                                 [0] = {
 618                                         .num = ST_ACCEL_FS_AVL_2G,
 619                                         .gain = IIO_G_TO_M_S_2(488),
 620                                 },
 621                         },
 622                 },
 623                 /*
 624                  * The part has a BDU bit but if set the data is never
 625                  * updated so don't set it.
 626                  */
 627                 .bdu = {
 628                 },
 629                 .drdy_irq = {
 630                         .int1 = {
 631                                 .addr = 0x21,
 632                                 .mask = 0x04,
 633                         },
 634                         .stat_drdy = {
 635                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 636                                 .mask = 0x07,
 637                         },
 638                 },
 639                 .sim = {
 640                         .addr = 0x21,
 641                         .value = BIT(1),
 642                 },
 643                 .multi_read_bit = false,
 644                 .bootime = 2,
 645         },
 646         {
 647                 .wai = 0x33,
 648                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 649                 .sensors_supported = {
 650                         [0] = LNG2DM_ACCEL_DEV_NAME,
 651                 },
 652                 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
 653                 .odr = {
 654                         .addr = 0x20,
 655                         .mask = 0xf0,
 656                         .odr_avl = {
 657                                 { .hz = 1, .value = 0x01, },
 658                                 { .hz = 10, .value = 0x02, },
 659                                 { .hz = 25, .value = 0x03, },
 660                                 { .hz = 50, .value = 0x04, },
 661                                 { .hz = 100, .value = 0x05, },
 662                                 { .hz = 200, .value = 0x06, },
 663                                 { .hz = 400, .value = 0x07, },
 664                                 { .hz = 1600, .value = 0x08, },
 665                         },
 666                 },
 667                 .pw = {
 668                         .addr = 0x20,
 669                         .mask = 0xf0,
 670                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 671                 },
 672                 .enable_axis = {
 673                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 674                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 675                 },
 676                 .fs = {
 677                         .addr = 0x23,
 678                         .mask = 0x30,
 679                         .fs_avl = {
 680                                 [0] = {
 681                                         .num = ST_ACCEL_FS_AVL_2G,
 682                                         .value = 0x00,
 683                                         .gain = IIO_G_TO_M_S_2(15600),
 684                                 },
 685                                 [1] = {
 686                                         .num = ST_ACCEL_FS_AVL_4G,
 687                                         .value = 0x01,
 688                                         .gain = IIO_G_TO_M_S_2(31200),
 689                                 },
 690                                 [2] = {
 691                                         .num = ST_ACCEL_FS_AVL_8G,
 692                                         .value = 0x02,
 693                                         .gain = IIO_G_TO_M_S_2(62500),
 694                                 },
 695                                 [3] = {
 696                                         .num = ST_ACCEL_FS_AVL_16G,
 697                                         .value = 0x03,
 698                                         .gain = IIO_G_TO_M_S_2(187500),
 699                                 },
 700                         },
 701                 },
 702                 .drdy_irq = {
 703                         .int1 = {
 704                                 .addr = 0x22,
 705                                 .mask = 0x10,
 706                         },
 707                         .addr_ihl = 0x25,
 708                         .mask_ihl = 0x02,
 709                         .stat_drdy = {
 710                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 711                                 .mask = 0x07,
 712                         },
 713                 },
 714                 .sim = {
 715                         .addr = 0x23,
 716                         .value = BIT(0),
 717                 },
 718                 .multi_read_bit = true,
 719                 .bootime = 2,
 720         },
 721         {
 722                 .wai = 0x44,
 723                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 724                 .sensors_supported = {
 725                         [0] = LIS2DW12_ACCEL_DEV_NAME,
 726                 },
 727                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 728                 .odr = {
 729                         .addr = 0x20,
 730                         .mask = 0xf0,
 731                         .odr_avl = {
 732                                 { .hz = 1, .value = 0x01, },
 733                                 { .hz = 12, .value = 0x02, },
 734                                 { .hz = 25, .value = 0x03, },
 735                                 { .hz = 50, .value = 0x04, },
 736                                 { .hz = 100, .value = 0x05, },
 737                                 { .hz = 200, .value = 0x06, },
 738                         },
 739                 },
 740                 .pw = {
 741                         .addr = 0x20,
 742                         .mask = 0xf0,
 743                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 744                 },
 745                 .fs = {
 746                         .addr = 0x25,
 747                         .mask = 0x30,
 748                         .fs_avl = {
 749                                 [0] = {
 750                                         .num = ST_ACCEL_FS_AVL_2G,
 751                                         .value = 0x00,
 752                                         .gain = IIO_G_TO_M_S_2(976),
 753                                 },
 754                                 [1] = {
 755                                         .num = ST_ACCEL_FS_AVL_4G,
 756                                         .value = 0x01,
 757                                         .gain = IIO_G_TO_M_S_2(1952),
 758                                 },
 759                                 [2] = {
 760                                         .num = ST_ACCEL_FS_AVL_8G,
 761                                         .value = 0x02,
 762                                         .gain = IIO_G_TO_M_S_2(3904),
 763                                 },
 764                                 [3] = {
 765                                         .num = ST_ACCEL_FS_AVL_16G,
 766                                         .value = 0x03,
 767                                         .gain = IIO_G_TO_M_S_2(7808),
 768                                 },
 769                         },
 770                 },
 771                 .bdu = {
 772                         .addr = 0x21,
 773                         .mask = 0x08,
 774                 },
 775                 .drdy_irq = {
 776                         .int1 = {
 777                                 .addr = 0x23,
 778                                 .mask = 0x01,
 779                                 .addr_od = 0x22,
 780                                 .mask_od = 0x20,
 781                         },
 782                         .int2 = {
 783                                 .addr = 0x24,
 784                                 .mask = 0x01,
 785                                 .addr_od = 0x22,
 786                                 .mask_od = 0x20,
 787                         },
 788                         .addr_ihl = 0x22,
 789                         .mask_ihl = 0x08,
 790                         .stat_drdy = {
 791                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 792                                 .mask = 0x01,
 793                         },
 794                 },
 795                 .sim = {
 796                         .addr = 0x21,
 797                         .value = BIT(0),
 798                 },
 799                 .multi_read_bit = false,
 800                 .bootime = 2,
 801         },
 802         {
 803                 .wai = 0x11,
 804                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 805                 .sensors_supported = {
 806                         [0] = LIS3DHH_ACCEL_DEV_NAME,
 807                 },
 808                 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
 809                 .odr = {
 810                         /* just ODR = 1100Hz available */
 811                         .odr_avl = {
 812                                 { .hz = 1100, .value = 0x00, },
 813                         },
 814                 },
 815                 .pw = {
 816                         .addr = 0x20,
 817                         .mask = 0x80,
 818                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 819                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 820                 },
 821                 .fs = {
 822                         .fs_avl = {
 823                                 [0] = {
 824                                         .num = ST_ACCEL_FS_AVL_2G,
 825                                         .gain = IIO_G_TO_M_S_2(76),
 826                                 },
 827                         },
 828                 },
 829                 .bdu = {
 830                         .addr = 0x20,
 831                         .mask = 0x01,
 832                 },
 833                 .drdy_irq = {
 834                         .int1 = {
 835                                 .addr = 0x21,
 836                                 .mask = 0x80,
 837                                 .addr_od = 0x23,
 838                                 .mask_od = 0x04,
 839                         },
 840                         .int2 = {
 841                                 .addr = 0x22,
 842                                 .mask = 0x80,
 843                                 .addr_od = 0x23,
 844                                 .mask_od = 0x08,
 845                         },
 846                         .stat_drdy = {
 847                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 848                                 .mask = 0x07,
 849                         },
 850                 },
 851                 .multi_read_bit = false,
 852                 .bootime = 2,
 853         },
 854         {
 855                 .wai = 0x33,
 856                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 857                 .sensors_supported = {
 858                         [0] = LIS2DE12_ACCEL_DEV_NAME,
 859                 },
 860                 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
 861                 .odr = {
 862                         .addr = 0x20,
 863                         .mask = 0xf0,
 864                         .odr_avl = {
 865                                 { .hz = 1, .value = 0x01, },
 866                                 { .hz = 10, .value = 0x02, },
 867                                 { .hz = 25, .value = 0x03, },
 868                                 { .hz = 50, .value = 0x04, },
 869                                 { .hz = 100, .value = 0x05, },
 870                                 { .hz = 200, .value = 0x06, },
 871                                 { .hz = 400, .value = 0x07, },
 872                                 { .hz = 1620, .value = 0x08, },
 873                                 { .hz = 5376, .value = 0x09, },
 874                         },
 875                 },
 876                 .pw = {
 877                         .addr = 0x20,
 878                         .mask = 0xf0,
 879                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 880                 },
 881                 .enable_axis = {
 882                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 883                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 884                 },
 885                 .fs = {
 886                         .addr = 0x23,
 887                         .mask = 0x30,
 888                         .fs_avl = {
 889                                 [0] = {
 890                                         .num = ST_ACCEL_FS_AVL_2G,
 891                                         .value = 0x00,
 892                                         .gain = IIO_G_TO_M_S_2(15600),
 893                                 },
 894                                 [1] = {
 895                                         .num = ST_ACCEL_FS_AVL_4G,
 896                                         .value = 0x01,
 897                                         .gain = IIO_G_TO_M_S_2(31200),
 898                                 },
 899                                 [2] = {
 900                                         .num = ST_ACCEL_FS_AVL_8G,
 901                                         .value = 0x02,
 902                                         .gain = IIO_G_TO_M_S_2(62500),
 903                                 },
 904                                 [3] = {
 905                                         .num = ST_ACCEL_FS_AVL_16G,
 906                                         .value = 0x03,
 907                                         .gain = IIO_G_TO_M_S_2(187500),
 908                                 },
 909                         },
 910                 },
 911                 .drdy_irq = {
 912                         .int1 = {
 913                                 .addr = 0x22,
 914                                 .mask = 0x10,
 915                         },
 916                         .addr_ihl = 0x25,
 917                         .mask_ihl = 0x02,
 918                         .stat_drdy = {
 919                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 920                                 .mask = 0x07,
 921                         },
 922                 },
 923                 .sim = {
 924                         .addr = 0x23,
 925                         .value = BIT(0),
 926                 },
 927                 .multi_read_bit = true,
 928                 .bootime = 2,
 929         },
 930         {
 931                 .wai = 0x41,
 932                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 933                 .sensors_supported = {
 934                         [0] = LIS2HH12_ACCEL_DEV_NAME,
 935                 },
 936                 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
 937                 .odr = {
 938                         .addr = 0x20,
 939                         .mask = 0x70,
 940                         .odr_avl = {
 941                                 { .hz = 10, .value = 0x01, },
 942                                 { .hz = 50, .value = 0x02, },
 943                                 { .hz = 100, .value = 0x03, },
 944                                 { .hz = 200, .value = 0x04, },
 945                                 { .hz = 400, .value = 0x05, },
 946                                 { .hz = 800, .value = 0x06, },
 947                         },
 948                 },
 949                 .pw = {
 950                         .addr = 0x20,
 951                         .mask = 0x70,
 952                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 953                 },
 954                 .enable_axis = {
 955                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 956                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 957                 },
 958                 .fs = {
 959                         .addr = 0x23,
 960                         .mask = 0x30,
 961                         .fs_avl = {
 962                                 [0] = {
 963                                         .num = ST_ACCEL_FS_AVL_2G,
 964                                         .value = 0x00,
 965                                         .gain = IIO_G_TO_M_S_2(61),
 966                                 },
 967                                 [1] = {
 968                                         .num = ST_ACCEL_FS_AVL_4G,
 969                                         .value = 0x02,
 970                                         .gain = IIO_G_TO_M_S_2(122),
 971                                 },
 972                                 [2] = {
 973                                         .num = ST_ACCEL_FS_AVL_8G,
 974                                         .value = 0x03,
 975                                         .gain = IIO_G_TO_M_S_2(244),
 976                                 },
 977                         },
 978                 },
 979                 .bdu = {
 980                         .addr = 0x20,
 981                         .mask = 0x08,
 982                 },
 983                 .drdy_irq = {
 984                         .int1 = {
 985                                 .addr = 0x22,
 986                                 .mask = 0x01,
 987                         },
 988                         .int2 = {
 989                                 .addr = 0x25,
 990                                 .mask = 0x01,
 991                         },
 992                         .addr_ihl = 0x24,
 993                         .mask_ihl = 0x02,
 994                         .stat_drdy = {
 995                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 996                                 .mask = 0x07,
 997                         },
 998                 },
 999                 .sim = {
1000                         .addr = 0x23,
1001                         .value = BIT(0),
1002                 },
1003                 .multi_read_bit = true,
1004                 .bootime = 2,
1005         },
1006         {
1007                 .wai = 0x49,
1008                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1009                 .sensors_supported = {
1010                         [0] = LSM9DS0_IMU_DEV_NAME,
1011                 },
1012                 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
1013                 .odr = {
1014                         .addr = 0x20,
1015                         .mask = GENMASK(7, 4),
1016                         .odr_avl = {
1017                                 { 3, 0x01, },
1018                                 { 6, 0x02, },
1019                                 { 12, 0x03, },
1020                                 { 25, 0x04, },
1021                                 { 50, 0x05, },
1022                                 { 100, 0x06, },
1023                                 { 200, 0x07, },
1024                                 { 400, 0x08, },
1025                                 { 800, 0x09, },
1026                                 { 1600, 0x0a, },
1027                         },
1028                 },
1029                 .pw = {
1030                         .addr = 0x20,
1031                         .mask = GENMASK(7, 4),
1032                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1033                 },
1034                 .enable_axis = {
1035                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1036                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1037                 },
1038                 .fs = {
1039                         .addr = 0x21,
1040                         .mask = GENMASK(5, 3),
1041                         .fs_avl = {
1042                                 [0] = {
1043                                         .num = ST_ACCEL_FS_AVL_2G,
1044                                         .value = 0x00,
1045                                         .gain = IIO_G_TO_M_S_2(61),
1046                                 },
1047                                 [1] = {
1048                                         .num = ST_ACCEL_FS_AVL_4G,
1049                                         .value = 0x01,
1050                                         .gain = IIO_G_TO_M_S_2(122),
1051                                 },
1052                                 [2] = {
1053                                         .num = ST_ACCEL_FS_AVL_6G,
1054                                         .value = 0x02,
1055                                         .gain = IIO_G_TO_M_S_2(183),
1056                                 },
1057                                 [3] = {
1058                                         .num = ST_ACCEL_FS_AVL_8G,
1059                                         .value = 0x03,
1060                                         .gain = IIO_G_TO_M_S_2(244),
1061                                 },
1062                                 [4] = {
1063                                         .num = ST_ACCEL_FS_AVL_16G,
1064                                         .value = 0x04,
1065                                         .gain = IIO_G_TO_M_S_2(732),
1066                                 },
1067                         },
1068                 },
1069                 .bdu = {
1070                         .addr = 0x20,
1071                         .mask = BIT(3),
1072                 },
1073                 .drdy_irq = {
1074                         .int1 = {
1075                                 .addr = 0x22,
1076                                 .mask = BIT(2),
1077                         },
1078                         .int2 = {
1079                                 .addr = 0x23,
1080                                 .mask = BIT(3),
1081                         },
1082                         .stat_drdy = {
1083                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1084                                 .mask = GENMASK(2, 0),
1085                         },
1086                 },
1087                 .sim = {
1088                         .addr = 0x21,
1089                         .value = BIT(0),
1090                 },
1091                 .multi_read_bit = true,
1092                 .bootime = 2,
1093         },
1094 };
1095
1096 /* Default accel DRDY is available on INT1 pin */
1097 static const struct st_sensors_platform_data default_accel_pdata = {
1098         .drdy_int_pin = 1,
1099 };
1100
1101 static int st_accel_read_raw(struct iio_dev *indio_dev,
1102                         struct iio_chan_spec const *ch, int *val,
1103                                                         int *val2, long mask)
1104 {
1105         int err;
1106         struct st_sensor_data *adata = iio_priv(indio_dev);
1107
1108         switch (mask) {
1109         case IIO_CHAN_INFO_RAW:
1110                 err = st_sensors_read_info_raw(indio_dev, ch, val);
1111                 if (err < 0)
1112                         goto read_error;
1113
1114                 return IIO_VAL_INT;
1115         case IIO_CHAN_INFO_SCALE:
1116                 *val = adata->current_fullscale->gain / 1000000;
1117                 *val2 = adata->current_fullscale->gain % 1000000;
1118                 return IIO_VAL_INT_PLUS_MICRO;
1119         case IIO_CHAN_INFO_SAMP_FREQ:
1120                 *val = adata->odr;
1121                 return IIO_VAL_INT;
1122         default:
1123                 return -EINVAL;
1124         }
1125
1126 read_error:
1127         return err;
1128 }
1129
1130 static int st_accel_write_raw(struct iio_dev *indio_dev,
1131                 struct iio_chan_spec const *chan, int val, int val2, long mask)
1132 {
1133         int err;
1134
1135         switch (mask) {
1136         case IIO_CHAN_INFO_SCALE: {
1137                 int gain;
1138
1139                 gain = val * 1000000 + val2;
1140                 err = st_sensors_set_fullscale_by_gain(indio_dev, gain);
1141                 break;
1142         }
1143         case IIO_CHAN_INFO_SAMP_FREQ:
1144                 if (val2)
1145                         return -EINVAL;
1146                 mutex_lock(&indio_dev->mlock);
1147                 err = st_sensors_set_odr(indio_dev, val);
1148                 mutex_unlock(&indio_dev->mlock);
1149                 return err;
1150         default:
1151                 return -EINVAL;
1152         }
1153
1154         return err;
1155 }
1156
1157 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
1158 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
1159
1160 static struct attribute *st_accel_attributes[] = {
1161         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1162         &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
1163         NULL,
1164 };
1165
1166 static const struct attribute_group st_accel_attribute_group = {
1167         .attrs = st_accel_attributes,
1168 };
1169
1170 static const struct iio_info accel_info = {
1171         .attrs = &st_accel_attribute_group,
1172         .read_raw = &st_accel_read_raw,
1173         .write_raw = &st_accel_write_raw,
1174         .debugfs_reg_access = &st_sensors_debugfs_reg_access,
1175 };
1176
1177 #ifdef CONFIG_IIO_TRIGGER
1178 static const struct iio_trigger_ops st_accel_trigger_ops = {
1179         .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE,
1180         .validate_device = st_sensors_validate_device,
1181 };
1182 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops)
1183 #else
1184 #define ST_ACCEL_TRIGGER_OPS NULL
1185 #endif
1186
1187 #ifdef CONFIG_ACPI
1188 /* Read ST-specific _ONT orientation data from ACPI and generate an
1189  * appropriate mount matrix.
1190  */
1191 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1192 {
1193         struct st_sensor_data *adata = iio_priv(indio_dev);
1194         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1195         struct acpi_device *adev;
1196         union acpi_object *ont;
1197         union acpi_object *elements;
1198         acpi_status status;
1199         int ret = -EINVAL;
1200         unsigned int val;
1201         int i, j;
1202         int final_ont[3][3] = { { 0 }, };
1203
1204         /* For some reason, ST's _ONT translation does not apply directly
1205          * to the data read from the sensor. Another translation must be
1206          * performed first, as described by the matrix below. Perhaps
1207          * ST required this specific translation for the first product
1208          * where the device was mounted?
1209          */
1210         const int default_ont[3][3] = {
1211                 {  0,  1,  0 },
1212                 { -1,  0,  0 },
1213                 {  0,  0, -1 },
1214         };
1215
1216
1217         adev = ACPI_COMPANION(adata->dev);
1218         if (!adev)
1219                 return 0;
1220
1221         /* Read _ONT data, which should be a package of 6 integers. */
1222         status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer);
1223         if (status == AE_NOT_FOUND) {
1224                 return 0;
1225         } else if (ACPI_FAILURE(status)) {
1226                 dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n",
1227                          status);
1228                 return status;
1229         }
1230
1231         ont = buffer.pointer;
1232         if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6)
1233                 goto out;
1234
1235         /* The first 3 integers provide axis order information.
1236          * e.g. 0 1 2 would indicate normal X,Y,Z ordering.
1237          * e.g. 1 0 2 indicates that data arrives in order Y,X,Z.
1238          */
1239         elements = ont->package.elements;
1240         for (i = 0; i < 3; i++) {
1241                 if (elements[i].type != ACPI_TYPE_INTEGER)
1242                         goto out;
1243
1244                 val = elements[i].integer.value;
1245                 if (val > 2)
1246                         goto out;
1247
1248                 /* Avoiding full matrix multiplication, we simply reorder the
1249                  * columns in the default_ont matrix according to the
1250                  * ordering provided by _ONT.
1251                  */
1252                 final_ont[0][i] = default_ont[0][val];
1253                 final_ont[1][i] = default_ont[1][val];
1254                 final_ont[2][i] = default_ont[2][val];
1255         }
1256
1257         /* The final 3 integers provide sign flip information.
1258          * 0 means no change, 1 means flip.
1259          * e.g. 0 0 1 means that Z data should be sign-flipped.
1260          * This is applied after the axis reordering from above.
1261          */
1262         elements += 3;
1263         for (i = 0; i < 3; i++) {
1264                 if (elements[i].type != ACPI_TYPE_INTEGER)
1265                         goto out;
1266
1267                 val = elements[i].integer.value;
1268                 if (val != 0 && val != 1)
1269                         goto out;
1270                 if (!val)
1271                         continue;
1272
1273                 /* Flip the values in the indicated column */
1274                 final_ont[0][i] *= -1;
1275                 final_ont[1][i] *= -1;
1276                 final_ont[2][i] *= -1;
1277         }
1278
1279         /* Convert our integer matrix to a string-based iio_mount_matrix */
1280         for (i = 0; i < 3; i++) {
1281                 for (j = 0; j < 3; j++) {
1282                         int matrix_val = final_ont[i][j];
1283                         char *str_value;
1284
1285                         switch (matrix_val) {
1286                         case -1:
1287                                 str_value = "-1";
1288                                 break;
1289                         case 0:
1290                                 str_value = "0";
1291                                 break;
1292                         case 1:
1293                                 str_value = "1";
1294                                 break;
1295                         default:
1296                                 goto out;
1297                         }
1298                         adata->mount_matrix.rotation[i * 3 + j] = str_value;
1299                 }
1300         }
1301
1302         ret = 0;
1303         dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n");
1304
1305 out:
1306         kfree(buffer.pointer);
1307         if (ret)
1308                 dev_dbg(&indio_dev->dev,
1309                         "failed to apply ACPI orientation data: %d\n", ret);
1310
1311         return ret;
1312 }
1313 #else /* !CONFIG_ACPI */
1314 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1315 {
1316         return -EINVAL;
1317 }
1318 #endif
1319
1320 /*
1321  * st_accel_get_settings() - get sensor settings from device name
1322  * @name: device name buffer reference.
1323  *
1324  * Return: valid reference on success, NULL otherwise.
1325  */
1326 const struct st_sensor_settings *st_accel_get_settings(const char *name)
1327 {
1328         int index = st_sensors_get_settings_index(name,
1329                                         st_accel_sensors_settings,
1330                                         ARRAY_SIZE(st_accel_sensors_settings));
1331         if (index < 0)
1332                 return NULL;
1333
1334         return &st_accel_sensors_settings[index];
1335 }
1336 EXPORT_SYMBOL(st_accel_get_settings);
1337
1338 int st_accel_common_probe(struct iio_dev *indio_dev)
1339 {
1340         struct st_sensor_data *adata = iio_priv(indio_dev);
1341         struct st_sensors_platform_data *pdata = dev_get_platdata(adata->dev);
1342         int err;
1343
1344         indio_dev->modes = INDIO_DIRECT_MODE;
1345         indio_dev->info = &accel_info;
1346
1347         err = st_sensors_verify_id(indio_dev);
1348         if (err < 0)
1349                 return err;
1350
1351         adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
1352         indio_dev->channels = adata->sensor_settings->ch;
1353         indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
1354
1355         /*
1356          * First try specific ACPI methods to retrieve orientation then try the
1357          * generic function.
1358          */
1359         err = apply_acpi_orientation(indio_dev);
1360         if (err) {
1361                 err = iio_read_mount_matrix(adata->dev, &adata->mount_matrix);
1362                 if (err)
1363                         return err;
1364         }
1365
1366         adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0];
1367         adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
1368
1369         if (!pdata)
1370                 pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
1371
1372         err = st_sensors_init_sensor(indio_dev, pdata);
1373         if (err < 0)
1374                 return err;
1375
1376         err = st_accel_allocate_ring(indio_dev);
1377         if (err < 0)
1378                 return err;
1379
1380         if (adata->irq > 0) {
1381                 err = st_sensors_allocate_trigger(indio_dev,
1382                                                  ST_ACCEL_TRIGGER_OPS);
1383                 if (err < 0)
1384                         goto st_accel_probe_trigger_error;
1385         }
1386
1387         err = iio_device_register(indio_dev);
1388         if (err)
1389                 goto st_accel_device_register_error;
1390
1391         dev_info(&indio_dev->dev, "registered accelerometer %s\n",
1392                  indio_dev->name);
1393
1394         return 0;
1395
1396 st_accel_device_register_error:
1397         if (adata->irq > 0)
1398                 st_sensors_deallocate_trigger(indio_dev);
1399 st_accel_probe_trigger_error:
1400         st_accel_deallocate_ring(indio_dev);
1401         return err;
1402 }
1403 EXPORT_SYMBOL(st_accel_common_probe);
1404
1405 void st_accel_common_remove(struct iio_dev *indio_dev)
1406 {
1407         struct st_sensor_data *adata = iio_priv(indio_dev);
1408
1409         iio_device_unregister(indio_dev);
1410         if (adata->irq > 0)
1411                 st_sensors_deallocate_trigger(indio_dev);
1412
1413         st_accel_deallocate_ring(indio_dev);
1414 }
1415 EXPORT_SYMBOL(st_accel_common_remove);
1416
1417 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
1418 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");
1419 MODULE_LICENSE("GPL v2");