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