iio/accel/st_accel_core.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * STMicroelectronics accelerometers driver
0004  *
0005  * Copyright 2012-2013 STMicroelectronics Inc.
0006  *
0007  * Denis Ciocca <denis.ciocca@st.com>
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/mutex.h>
0013 #include <linux/sysfs.h>
0014 #include <linux/slab.h>
0015 #include <linux/acpi.h>
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/sysfs.h>
0018 #include <linux/iio/trigger.h>
0019
0020 #include <linux/iio/common/st_sensors.h>
0021 #include "st_accel.h"
0022
0023 #define ST_ACCEL_NUMBER_DATA_CHANNELS       3
0024
0025 /* DEFAULT VALUE FOR SENSORS */
0026 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR       0x28
0027 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR       0x2a
0028 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR       0x2c
0029
0030 /* FULLSCALE */
0031 #define ST_ACCEL_FS_AVL_2G          2
0032 #define ST_ACCEL_FS_AVL_4G          4
0033 #define ST_ACCEL_FS_AVL_6G          6
0034 #define ST_ACCEL_FS_AVL_8G          8
0035 #define ST_ACCEL_FS_AVL_16G         16
0036 #define ST_ACCEL_FS_AVL_100G            100
0037 #define ST_ACCEL_FS_AVL_200G            200
0038 #define ST_ACCEL_FS_AVL_400G            400
0039
0040 static const struct iio_mount_matrix *
0041 st_accel_get_mount_matrix(const struct iio_dev *indio_dev,
0042               const struct iio_chan_spec *chan)
0043 {
0044     struct st_sensor_data *adata = iio_priv(indio_dev);
0045
0046     return &adata->mount_matrix;
0047 }
0048
0049 static const struct iio_chan_spec_ext_info st_accel_mount_matrix_ext_info[] = {
0050     IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_accel_get_mount_matrix),
0051     { }
0052 };
0053
0054 static const struct iio_chan_spec st_accel_8bit_channels[] = {
0055     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0056             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0057             ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
0058             ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1,
0059             st_accel_mount_matrix_ext_info),
0060     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0061             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0062             ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
0063             ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1,
0064             st_accel_mount_matrix_ext_info),
0065     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0066             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0067             ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
0068             ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1,
0069             st_accel_mount_matrix_ext_info),
0070     IIO_CHAN_SOFT_TIMESTAMP(3)
0071 };
0072
0073 static const struct iio_chan_spec st_accel_12bit_channels[] = {
0074     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0075             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0076             ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
0077             ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
0078             st_accel_mount_matrix_ext_info),
0079     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0080             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0081             ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
0082             ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
0083             st_accel_mount_matrix_ext_info),
0084     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0085             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0086             ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
0087             ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
0088             st_accel_mount_matrix_ext_info),
0089     IIO_CHAN_SOFT_TIMESTAMP(3)
0090 };
0091
0092 static const struct iio_chan_spec st_accel_16bit_channels[] = {
0093     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0094             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0095             ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
0096             ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
0097             st_accel_mount_matrix_ext_info),
0098     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0099             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0100             ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
0101             ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
0102             st_accel_mount_matrix_ext_info),
0103     ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
0104             BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0105             ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
0106             ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
0107             st_accel_mount_matrix_ext_info),
0108     IIO_CHAN_SOFT_TIMESTAMP(3)
0109 };
0110
0111 static const struct st_sensor_settings st_accel_sensors_settings[] = {
0112     {
0113         .wai = 0x33,
0114         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0115         .sensors_supported = {
0116             [0] = LIS3DH_ACCEL_DEV_NAME,
0117             [1] = LSM303DLHC_ACCEL_DEV_NAME,
0118             [2] = LSM330D_ACCEL_DEV_NAME,
0119             [3] = LSM330DL_ACCEL_DEV_NAME,
0120             [4] = LSM330DLC_ACCEL_DEV_NAME,
0121             [5] = LSM303AGR_ACCEL_DEV_NAME,
0122             [6] = LIS2DH12_ACCEL_DEV_NAME,
0123             [7] = LIS3DE_ACCEL_DEV_NAME,
0124         },
0125         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0126         .odr = {
0127             .addr = 0x20,
0128             .mask = 0xf0,
0129             .odr_avl = {
0130                 { .hz = 1, .value = 0x01, },
0131                 { .hz = 10, .value = 0x02, },
0132                 { .hz = 25, .value = 0x03, },
0133                 { .hz = 50, .value = 0x04, },
0134                 { .hz = 100, .value = 0x05, },
0135                 { .hz = 200, .value = 0x06, },
0136                 { .hz = 400, .value = 0x07, },
0137                 { .hz = 1600, .value = 0x08, },
0138             },
0139         },
0140         .pw = {
0141             .addr = 0x20,
0142             .mask = 0xf0,
0143             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0144         },
0145         .enable_axis = {
0146             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0147             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0148         },
0149         .fs = {
0150             .addr = 0x23,
0151             .mask = 0x30,
0152             .fs_avl = {
0153                 [0] = {
0154                     .num = ST_ACCEL_FS_AVL_2G,
0155                     .value = 0x00,
0156                     .gain = IIO_G_TO_M_S_2(1000),
0157                 },
0158                 [1] = {
0159                     .num = ST_ACCEL_FS_AVL_4G,
0160                     .value = 0x01,
0161                     .gain = IIO_G_TO_M_S_2(2000),
0162                 },
0163                 [2] = {
0164                     .num = ST_ACCEL_FS_AVL_8G,
0165                     .value = 0x02,
0166                     .gain = IIO_G_TO_M_S_2(4000),
0167                 },
0168                 [3] = {
0169                     .num = ST_ACCEL_FS_AVL_16G,
0170                     .value = 0x03,
0171                     .gain = IIO_G_TO_M_S_2(12000),
0172                 },
0173             },
0174         },
0175         .bdu = {
0176             .addr = 0x23,
0177             .mask = 0x80,
0178         },
0179         .drdy_irq = {
0180             .int1 = {
0181                 .addr = 0x22,
0182                 .mask = 0x10,
0183             },
0184             .addr_ihl = 0x25,
0185             .mask_ihl = 0x02,
0186             .stat_drdy = {
0187                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0188                 .mask = 0x07,
0189             },
0190         },
0191         .sim = {
0192             .addr = 0x23,
0193             .value = BIT(0),
0194         },
0195         .multi_read_bit = true,
0196         .bootime = 2,
0197     },
0198     {
0199         .wai = 0x32,
0200         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0201         .sensors_supported = {
0202             [0] = LIS331DLH_ACCEL_DEV_NAME,
0203             [1] = LSM303DL_ACCEL_DEV_NAME,
0204             [2] = LSM303DLH_ACCEL_DEV_NAME,
0205             [3] = LSM303DLM_ACCEL_DEV_NAME,
0206         },
0207         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0208         .odr = {
0209             .addr = 0x20,
0210             .mask = 0x18,
0211             .odr_avl = {
0212                 { .hz = 50, .value = 0x00, },
0213                 { .hz = 100, .value = 0x01, },
0214                 { .hz = 400, .value = 0x02, },
0215                 { .hz = 1000, .value = 0x03, },
0216             },
0217         },
0218         .pw = {
0219             .addr = 0x20,
0220             .mask = 0xe0,
0221             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0222             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0223         },
0224         .enable_axis = {
0225             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0226             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0227         },
0228         .fs = {
0229             .addr = 0x23,
0230             .mask = 0x30,
0231             .fs_avl = {
0232                 [0] = {
0233                     .num = ST_ACCEL_FS_AVL_2G,
0234                     .value = 0x00,
0235                     .gain = IIO_G_TO_M_S_2(1000),
0236                 },
0237                 [1] = {
0238                     .num = ST_ACCEL_FS_AVL_4G,
0239                     .value = 0x01,
0240                     .gain = IIO_G_TO_M_S_2(2000),
0241                 },
0242                 [2] = {
0243                     .num = ST_ACCEL_FS_AVL_8G,
0244                     .value = 0x03,
0245                     .gain = IIO_G_TO_M_S_2(3900),
0246                 },
0247             },
0248         },
0249         .bdu = {
0250             .addr = 0x23,
0251             .mask = 0x80,
0252         },
0253         .drdy_irq = {
0254             .int1 = {
0255                 .addr = 0x22,
0256                 .mask = 0x02,
0257                 .addr_od = 0x22,
0258                 .mask_od = 0x40,
0259             },
0260             .int2 = {
0261                 .addr = 0x22,
0262                 .mask = 0x10,
0263                 .addr_od = 0x22,
0264                 .mask_od = 0x40,
0265             },
0266             .addr_ihl = 0x22,
0267             .mask_ihl = 0x80,
0268             .stat_drdy = {
0269                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0270                 .mask = 0x07,
0271             },
0272         },
0273         .sim = {
0274             .addr = 0x23,
0275             .value = BIT(0),
0276         },
0277         .multi_read_bit = true,
0278         .bootime = 2,
0279     },
0280     {
0281         .wai = 0x40,
0282         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0283         .sensors_supported = {
0284             [0] = LSM330_ACCEL_DEV_NAME,
0285         },
0286         .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
0287         .odr = {
0288             .addr = 0x20,
0289             .mask = 0xf0,
0290             .odr_avl = {
0291                 { .hz = 3, .value = 0x01, },
0292                 { .hz = 6, .value = 0x02, },
0293                 { .hz = 12, .value = 0x03, },
0294                 { .hz = 25, .value = 0x04, },
0295                 { .hz = 50, .value = 0x05, },
0296                 { .hz = 100, .value = 0x06, },
0297                 { .hz = 200, .value = 0x07, },
0298                 { .hz = 400, .value = 0x08, },
0299                 { .hz = 800, .value = 0x09, },
0300                 { .hz = 1600, .value = 0x0a, },
0301             },
0302         },
0303         .pw = {
0304             .addr = 0x20,
0305             .mask = 0xf0,
0306             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0307         },
0308         .enable_axis = {
0309             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0310             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0311         },
0312         .fs = {
0313             .addr = 0x24,
0314             .mask = 0x38,
0315             .fs_avl = {
0316                 [0] = {
0317                     .num = ST_ACCEL_FS_AVL_2G,
0318                     .value = 0x00,
0319                     .gain = IIO_G_TO_M_S_2(61),
0320                 },
0321                 [1] = {
0322                     .num = ST_ACCEL_FS_AVL_4G,
0323                     .value = 0x01,
0324                     .gain = IIO_G_TO_M_S_2(122),
0325                 },
0326                 [2] = {
0327                     .num = ST_ACCEL_FS_AVL_6G,
0328                     .value = 0x02,
0329                     .gain = IIO_G_TO_M_S_2(183),
0330                 },
0331                 [3] = {
0332                     .num = ST_ACCEL_FS_AVL_8G,
0333                     .value = 0x03,
0334                     .gain = IIO_G_TO_M_S_2(244),
0335                 },
0336                 [4] = {
0337                     .num = ST_ACCEL_FS_AVL_16G,
0338                     .value = 0x04,
0339                     .gain = IIO_G_TO_M_S_2(732),
0340                 },
0341             },
0342         },
0343         .bdu = {
0344             .addr = 0x20,
0345             .mask = 0x08,
0346         },
0347         .drdy_irq = {
0348             .int1 = {
0349                 .addr = 0x23,
0350                 .mask = 0x80,
0351             },
0352             .addr_ihl = 0x23,
0353             .mask_ihl = 0x40,
0354             .stat_drdy = {
0355                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0356                 .mask = 0x07,
0357             },
0358             .ig1 = {
0359                 .en_addr = 0x23,
0360                 .en_mask = 0x08,
0361             },
0362         },
0363         .sim = {
0364             .addr = 0x24,
0365             .value = BIT(0),
0366         },
0367         .multi_read_bit = false,
0368         .bootime = 2,
0369     },
0370     {
0371         .wai = 0x3a,
0372         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0373         .sensors_supported = {
0374             [0] = LIS3LV02DL_ACCEL_DEV_NAME,
0375         },
0376         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0377         .odr = {
0378             .addr = 0x20,
0379             .mask = 0x30, /* DF1 and DF0 */
0380             .odr_avl = {
0381                 { .hz = 40, .value = 0x00, },
0382                 { .hz = 160, .value = 0x01, },
0383                 { .hz = 640, .value = 0x02, },
0384                 { .hz = 2560, .value = 0x03, },
0385             },
0386         },
0387         .pw = {
0388             .addr = 0x20,
0389             .mask = 0xc0,
0390             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0391             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0392         },
0393         .enable_axis = {
0394             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0395             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0396         },
0397         .fs = {
0398             .addr = 0x21,
0399             .mask = 0x80,
0400             .fs_avl = {
0401                 [0] = {
0402                     .num = ST_ACCEL_FS_AVL_2G,
0403                     .value = 0x00,
0404                     .gain = IIO_G_TO_M_S_2(1000),
0405                 },
0406                 [1] = {
0407                     .num = ST_ACCEL_FS_AVL_6G,
0408                     .value = 0x01,
0409                     .gain = IIO_G_TO_M_S_2(3000),
0410                 },
0411             },
0412         },
0413         .bdu = {
0414             .addr = 0x21,
0415             .mask = 0x40,
0416         },
0417         /*
0418          * Data Alignment Setting - needs to be set to get
0419          * left-justified data like all other sensors.
0420          */
0421         .das = {
0422             .addr = 0x21,
0423             .mask = 0x01,
0424         },
0425         .drdy_irq = {
0426             .int1 = {
0427                 .addr = 0x21,
0428                 .mask = 0x04,
0429             },
0430             .stat_drdy = {
0431                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0432                 .mask = 0x07,
0433             },
0434         },
0435         .sim = {
0436             .addr = 0x21,
0437             .value = BIT(1),
0438         },
0439         .multi_read_bit = true,
0440         .bootime = 2, /* guess */
0441     },
0442     {
0443         .wai = 0x3b,
0444         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0445         .sensors_supported = {
0446             [0] = LIS331DL_ACCEL_DEV_NAME,
0447             [1] = LIS302DL_ACCEL_DEV_NAME,
0448         },
0449         .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
0450         .odr = {
0451             .addr = 0x20,
0452             .mask = 0x80,
0453             .odr_avl = {
0454                 { .hz = 100, .value = 0x00, },
0455                 { .hz = 400, .value = 0x01, },
0456             },
0457         },
0458         .pw = {
0459             .addr = 0x20,
0460             .mask = 0x40,
0461             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0462             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0463         },
0464         .enable_axis = {
0465             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0466             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0467         },
0468         .fs = {
0469             .addr = 0x20,
0470             .mask = 0x20,
0471             /*
0472              * TODO: check these resulting gain settings, these are
0473              * not in the datsheet
0474              */
0475             .fs_avl = {
0476                 [0] = {
0477                     .num = ST_ACCEL_FS_AVL_2G,
0478                     .value = 0x00,
0479                     .gain = IIO_G_TO_M_S_2(18000),
0480                 },
0481                 [1] = {
0482                     .num = ST_ACCEL_FS_AVL_8G,
0483                     .value = 0x01,
0484                     .gain = IIO_G_TO_M_S_2(72000),
0485                 },
0486             },
0487         },
0488         .drdy_irq = {
0489             .int1 = {
0490                 .addr = 0x22,
0491                 .mask = 0x04,
0492                 .addr_od = 0x22,
0493                 .mask_od = 0x40,
0494             },
0495             .int2 = {
0496                 .addr = 0x22,
0497                 .mask = 0x20,
0498                 .addr_od = 0x22,
0499                 .mask_od = 0x40,
0500             },
0501             .addr_ihl = 0x22,
0502             .mask_ihl = 0x80,
0503             .stat_drdy = {
0504                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0505                 .mask = 0x07,
0506             },
0507         },
0508         .sim = {
0509             .addr = 0x21,
0510             .value = BIT(7),
0511         },
0512         .multi_read_bit = false,
0513         .bootime = 2, /* guess */
0514     },
0515     {
0516         .wai = 0x32,
0517         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0518         .sensors_supported = {
0519             [0] = H3LIS331DL_ACCEL_DEV_NAME,
0520         },
0521         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0522         .odr = {
0523             .addr = 0x20,
0524             .mask = 0x18,
0525             .odr_avl = {
0526                 { .hz = 50, .value = 0x00, },
0527                 { .hz = 100, .value = 0x01, },
0528                 { .hz = 400, .value = 0x02, },
0529                 { .hz = 1000, .value = 0x03, },
0530             },
0531         },
0532         .pw = {
0533             .addr = 0x20,
0534             .mask = 0x20,
0535             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0536             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0537         },
0538         .enable_axis = {
0539             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0540             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0541         },
0542         .fs = {
0543             .addr = 0x23,
0544             .mask = 0x30,
0545             .fs_avl = {
0546                 [0] = {
0547                     .num = ST_ACCEL_FS_AVL_100G,
0548                     .value = 0x00,
0549                     .gain = IIO_G_TO_M_S_2(49000),
0550                 },
0551                 [1] = {
0552                     .num = ST_ACCEL_FS_AVL_200G,
0553                     .value = 0x01,
0554                     .gain = IIO_G_TO_M_S_2(98000),
0555                 },
0556                 [2] = {
0557                     .num = ST_ACCEL_FS_AVL_400G,
0558                     .value = 0x03,
0559                     .gain = IIO_G_TO_M_S_2(195000),
0560                 },
0561             },
0562         },
0563         .bdu = {
0564             .addr = 0x23,
0565             .mask = 0x80,
0566         },
0567         .drdy_irq = {
0568             .int1 = {
0569                 .addr = 0x22,
0570                 .mask = 0x02,
0571             },
0572             .int2 = {
0573                 .addr = 0x22,
0574                 .mask = 0x10,
0575             },
0576             .addr_ihl = 0x22,
0577             .mask_ihl = 0x80,
0578         },
0579         .sim = {
0580             .addr = 0x23,
0581             .value = BIT(0),
0582         },
0583         .multi_read_bit = true,
0584         .bootime = 2,
0585     },
0586     {
0587         /* No WAI register present */
0588         .sensors_supported = {
0589             [0] = LIS3L02DQ_ACCEL_DEV_NAME,
0590         },
0591         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0592         .odr = {
0593             .addr = 0x20,
0594             .mask = 0x30,
0595             .odr_avl = {
0596                 { .hz = 280, .value = 0x00, },
0597                 { .hz = 560, .value = 0x01, },
0598                 { .hz = 1120, .value = 0x02, },
0599                 { .hz = 4480, .value = 0x03, },
0600             },
0601         },
0602         .pw = {
0603             .addr = 0x20,
0604             .mask = 0xc0,
0605             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0606             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0607         },
0608         .enable_axis = {
0609             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0610             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0611         },
0612         .fs = {
0613             .fs_avl = {
0614                 [0] = {
0615                     .num = ST_ACCEL_FS_AVL_2G,
0616                     .gain = IIO_G_TO_M_S_2(488),
0617                 },
0618             },
0619         },
0620         /*
0621          * The part has a BDU bit but if set the data is never
0622          * updated so don't set it.
0623          */
0624         .bdu = {
0625         },
0626         .drdy_irq = {
0627             .int1 = {
0628                 .addr = 0x21,
0629                 .mask = 0x04,
0630             },
0631             .stat_drdy = {
0632                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0633                 .mask = 0x07,
0634             },
0635         },
0636         .sim = {
0637             .addr = 0x21,
0638             .value = BIT(1),
0639         },
0640         .multi_read_bit = false,
0641         .bootime = 2,
0642     },
0643     {
0644         .wai = 0x33,
0645         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0646         .sensors_supported = {
0647             [0] = LNG2DM_ACCEL_DEV_NAME,
0648         },
0649         .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
0650         .odr = {
0651             .addr = 0x20,
0652             .mask = 0xf0,
0653             .odr_avl = {
0654                 { .hz = 1, .value = 0x01, },
0655                 { .hz = 10, .value = 0x02, },
0656                 { .hz = 25, .value = 0x03, },
0657                 { .hz = 50, .value = 0x04, },
0658                 { .hz = 100, .value = 0x05, },
0659                 { .hz = 200, .value = 0x06, },
0660                 { .hz = 400, .value = 0x07, },
0661                 { .hz = 1600, .value = 0x08, },
0662             },
0663         },
0664         .pw = {
0665             .addr = 0x20,
0666             .mask = 0xf0,
0667             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0668         },
0669         .enable_axis = {
0670             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0671             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0672         },
0673         .fs = {
0674             .addr = 0x23,
0675             .mask = 0x30,
0676             .fs_avl = {
0677                 [0] = {
0678                     .num = ST_ACCEL_FS_AVL_2G,
0679                     .value = 0x00,
0680                     .gain = IIO_G_TO_M_S_2(15600),
0681                 },
0682                 [1] = {
0683                     .num = ST_ACCEL_FS_AVL_4G,
0684                     .value = 0x01,
0685                     .gain = IIO_G_TO_M_S_2(31200),
0686                 },
0687                 [2] = {
0688                     .num = ST_ACCEL_FS_AVL_8G,
0689                     .value = 0x02,
0690                     .gain = IIO_G_TO_M_S_2(62500),
0691                 },
0692                 [3] = {
0693                     .num = ST_ACCEL_FS_AVL_16G,
0694                     .value = 0x03,
0695                     .gain = IIO_G_TO_M_S_2(187500),
0696                 },
0697             },
0698         },
0699         .drdy_irq = {
0700             .int1 = {
0701                 .addr = 0x22,
0702                 .mask = 0x10,
0703             },
0704             .addr_ihl = 0x25,
0705             .mask_ihl = 0x02,
0706             .stat_drdy = {
0707                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0708                 .mask = 0x07,
0709             },
0710         },
0711         .sim = {
0712             .addr = 0x23,
0713             .value = BIT(0),
0714         },
0715         .multi_read_bit = true,
0716         .bootime = 2,
0717     },
0718     {
0719         .wai = 0x44,
0720         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0721         .sensors_supported = {
0722             [0] = LIS2DW12_ACCEL_DEV_NAME,
0723         },
0724         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
0725         .odr = {
0726             .addr = 0x20,
0727             .mask = 0xf0,
0728             .odr_avl = {
0729                 { .hz = 1, .value = 0x01, },
0730                 { .hz = 12, .value = 0x02, },
0731                 { .hz = 25, .value = 0x03, },
0732                 { .hz = 50, .value = 0x04, },
0733                 { .hz = 100, .value = 0x05, },
0734                 { .hz = 200, .value = 0x06, },
0735             },
0736         },
0737         .pw = {
0738             .addr = 0x20,
0739             .mask = 0xf0,
0740             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0741         },
0742         .fs = {
0743             .addr = 0x25,
0744             .mask = 0x30,
0745             .fs_avl = {
0746                 [0] = {
0747                     .num = ST_ACCEL_FS_AVL_2G,
0748                     .value = 0x00,
0749                     .gain = IIO_G_TO_M_S_2(976),
0750                 },
0751                 [1] = {
0752                     .num = ST_ACCEL_FS_AVL_4G,
0753                     .value = 0x01,
0754                     .gain = IIO_G_TO_M_S_2(1952),
0755                 },
0756                 [2] = {
0757                     .num = ST_ACCEL_FS_AVL_8G,
0758                     .value = 0x02,
0759                     .gain = IIO_G_TO_M_S_2(3904),
0760                 },
0761                 [3] = {
0762                     .num = ST_ACCEL_FS_AVL_16G,
0763                     .value = 0x03,
0764                     .gain = IIO_G_TO_M_S_2(7808),
0765                 },
0766             },
0767         },
0768         .bdu = {
0769             .addr = 0x21,
0770             .mask = 0x08,
0771         },
0772         .drdy_irq = {
0773             .int1 = {
0774                 .addr = 0x23,
0775                 .mask = 0x01,
0776                 .addr_od = 0x22,
0777                 .mask_od = 0x20,
0778             },
0779             .int2 = {
0780                 .addr = 0x24,
0781                 .mask = 0x01,
0782                 .addr_od = 0x22,
0783                 .mask_od = 0x20,
0784             },
0785             .addr_ihl = 0x22,
0786             .mask_ihl = 0x08,
0787             .stat_drdy = {
0788                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0789                 .mask = 0x01,
0790             },
0791         },
0792         .sim = {
0793             .addr = 0x21,
0794             .value = BIT(0),
0795         },
0796         .multi_read_bit = false,
0797         .bootime = 2,
0798     },
0799     {
0800         .wai = 0x11,
0801         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0802         .sensors_supported = {
0803             [0] = LIS3DHH_ACCEL_DEV_NAME,
0804         },
0805         .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
0806         .odr = {
0807             /* just ODR = 1100Hz available */
0808             .odr_avl = {
0809                 { .hz = 1100, .value = 0x00, },
0810             },
0811         },
0812         .pw = {
0813             .addr = 0x20,
0814             .mask = 0x80,
0815             .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
0816             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0817         },
0818         .fs = {
0819             .fs_avl = {
0820                 [0] = {
0821                     .num = ST_ACCEL_FS_AVL_2G,
0822                     .gain = IIO_G_TO_M_S_2(76),
0823                 },
0824             },
0825         },
0826         .bdu = {
0827             .addr = 0x20,
0828             .mask = 0x01,
0829         },
0830         .drdy_irq = {
0831             .int1 = {
0832                 .addr = 0x21,
0833                 .mask = 0x80,
0834                 .addr_od = 0x23,
0835                 .mask_od = 0x04,
0836             },
0837             .int2 = {
0838                 .addr = 0x22,
0839                 .mask = 0x80,
0840                 .addr_od = 0x23,
0841                 .mask_od = 0x08,
0842             },
0843             .stat_drdy = {
0844                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0845                 .mask = 0x07,
0846             },
0847         },
0848         .multi_read_bit = false,
0849         .bootime = 2,
0850     },
0851     {
0852         .wai = 0x33,
0853         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0854         .sensors_supported = {
0855             [0] = LIS2DE12_ACCEL_DEV_NAME,
0856         },
0857         .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
0858         .odr = {
0859             .addr = 0x20,
0860             .mask = 0xf0,
0861             .odr_avl = {
0862                 { .hz = 1, .value = 0x01, },
0863                 { .hz = 10, .value = 0x02, },
0864                 { .hz = 25, .value = 0x03, },
0865                 { .hz = 50, .value = 0x04, },
0866                 { .hz = 100, .value = 0x05, },
0867                 { .hz = 200, .value = 0x06, },
0868                 { .hz = 400, .value = 0x07, },
0869                 { .hz = 1620, .value = 0x08, },
0870                 { .hz = 5376, .value = 0x09, },
0871             },
0872         },
0873         .pw = {
0874             .addr = 0x20,
0875             .mask = 0xf0,
0876             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0877         },
0878         .enable_axis = {
0879             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0880             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0881         },
0882         .fs = {
0883             .addr = 0x23,
0884             .mask = 0x30,
0885             .fs_avl = {
0886                 [0] = {
0887                     .num = ST_ACCEL_FS_AVL_2G,
0888                     .value = 0x00,
0889                     .gain = IIO_G_TO_M_S_2(15600),
0890                 },
0891                 [1] = {
0892                     .num = ST_ACCEL_FS_AVL_4G,
0893                     .value = 0x01,
0894                     .gain = IIO_G_TO_M_S_2(31200),
0895                 },
0896                 [2] = {
0897                     .num = ST_ACCEL_FS_AVL_8G,
0898                     .value = 0x02,
0899                     .gain = IIO_G_TO_M_S_2(62500),
0900                 },
0901                 [3] = {
0902                     .num = ST_ACCEL_FS_AVL_16G,
0903                     .value = 0x03,
0904                     .gain = IIO_G_TO_M_S_2(187500),
0905                 },
0906             },
0907         },
0908         .drdy_irq = {
0909             .int1 = {
0910                 .addr = 0x22,
0911                 .mask = 0x10,
0912             },
0913             .addr_ihl = 0x25,
0914             .mask_ihl = 0x02,
0915             .stat_drdy = {
0916                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0917                 .mask = 0x07,
0918             },
0919         },
0920         .sim = {
0921             .addr = 0x23,
0922             .value = BIT(0),
0923         },
0924         .multi_read_bit = true,
0925         .bootime = 2,
0926     },
0927     {
0928         .wai = 0x41,
0929         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
0930         .sensors_supported = {
0931             [0] = LIS2HH12_ACCEL_DEV_NAME,
0932         },
0933         .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
0934         .odr = {
0935             .addr = 0x20,
0936             .mask = 0x70,
0937             .odr_avl = {
0938                 { .hz = 10, .value = 0x01, },
0939                 { .hz = 50, .value = 0x02, },
0940                 { .hz = 100, .value = 0x03, },
0941                 { .hz = 200, .value = 0x04, },
0942                 { .hz = 400, .value = 0x05, },
0943                 { .hz = 800, .value = 0x06, },
0944             },
0945         },
0946         .pw = {
0947             .addr = 0x20,
0948             .mask = 0x70,
0949             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
0950         },
0951         .enable_axis = {
0952             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
0953             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
0954         },
0955         .fs = {
0956             .addr = 0x23,
0957             .mask = 0x30,
0958             .fs_avl = {
0959                 [0] = {
0960                     .num = ST_ACCEL_FS_AVL_2G,
0961                     .value = 0x00,
0962                     .gain = IIO_G_TO_M_S_2(61),
0963                 },
0964                 [1] = {
0965                     .num = ST_ACCEL_FS_AVL_4G,
0966                     .value = 0x02,
0967                     .gain = IIO_G_TO_M_S_2(122),
0968                 },
0969                 [2] = {
0970                     .num = ST_ACCEL_FS_AVL_8G,
0971                     .value = 0x03,
0972                     .gain = IIO_G_TO_M_S_2(244),
0973                 },
0974             },
0975         },
0976         .bdu = {
0977             .addr = 0x20,
0978             .mask = 0x08,
0979         },
0980         .drdy_irq = {
0981             .int1 = {
0982                 .addr = 0x22,
0983                 .mask = 0x01,
0984             },
0985             .int2 = {
0986                 .addr = 0x25,
0987                 .mask = 0x01,
0988             },
0989             .addr_ihl = 0x24,
0990             .mask_ihl = 0x02,
0991             .stat_drdy = {
0992                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
0993                 .mask = 0x07,
0994             },
0995         },
0996         .sim = {
0997             .addr = 0x23,
0998             .value = BIT(0),
0999         },
1000         .multi_read_bit = true,
1001         .bootime = 2,
1002     },
1003     {
1004         .wai = 0x49,
1005         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1006         .sensors_supported = {
1007             [0] = LSM9DS0_IMU_DEV_NAME,
1008         },
1009         .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
1010         .odr = {
1011             .addr = 0x20,
1012             .mask = GENMASK(7, 4),
1013             .odr_avl = {
1014                 { 3, 0x01, },
1015                 { 6, 0x02, },
1016                 { 12, 0x03, },
1017                 { 25, 0x04, },
1018                 { 50, 0x05, },
1019                 { 100, 0x06, },
1020                 { 200, 0x07, },
1021                 { 400, 0x08, },
1022                 { 800, 0x09, },
1023                 { 1600, 0x0a, },
1024             },
1025         },
1026         .pw = {
1027             .addr = 0x20,
1028             .mask = GENMASK(7, 4),
1029             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1030         },
1031         .enable_axis = {
1032             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1033             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1034         },
1035         .fs = {
1036             .addr = 0x21,
1037             .mask = GENMASK(5, 3),
1038             .fs_avl = {
1039                 [0] = {
1040                     .num = ST_ACCEL_FS_AVL_2G,
1041                     .value = 0x00,
1042                     .gain = IIO_G_TO_M_S_2(61),
1043                 },
1044                 [1] = {
1045                     .num = ST_ACCEL_FS_AVL_4G,
1046                     .value = 0x01,
1047                     .gain = IIO_G_TO_M_S_2(122),
1048                 },
1049                 [2] = {
1050                     .num = ST_ACCEL_FS_AVL_6G,
1051                     .value = 0x02,
1052                     .gain = IIO_G_TO_M_S_2(183),
1053                 },
1054                 [3] = {
1055                     .num = ST_ACCEL_FS_AVL_8G,
1056                     .value = 0x03,
1057                     .gain = IIO_G_TO_M_S_2(244),
1058                 },
1059                 [4] = {
1060                     .num = ST_ACCEL_FS_AVL_16G,
1061                     .value = 0x04,
1062                     .gain = IIO_G_TO_M_S_2(732),
1063                 },
1064             },
1065         },
1066         .bdu = {
1067             .addr = 0x20,
1068             .mask = BIT(3),
1069         },
1070         .drdy_irq = {
1071             .int1 = {
1072                 .addr = 0x22,
1073                 .mask = BIT(2),
1074             },
1075             .int2 = {
1076                 .addr = 0x23,
1077                 .mask = BIT(3),
1078             },
1079             .stat_drdy = {
1080                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1081                 .mask = GENMASK(2, 0),
1082             },
1083         },
1084         .sim = {
1085             .addr = 0x21,
1086             .value = BIT(0),
1087         },
1088         .multi_read_bit = true,
1089         .bootime = 2,
1090     },
1091     {
1092         /*
1093          * Not an ST part. Register-compatible with the LIS2DH, even
1094          * though the WAI value is different.
1095          */
1096         .wai = 0x11,
1097         .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1098         .sensors_supported = {
1099             [0] = SC7A20_ACCEL_DEV_NAME,
1100         },
1101         .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
1102         .odr = {
1103             .addr = 0x20,
1104             .mask = 0xf0,
1105             .odr_avl = {
1106                 { .hz = 1, .value = 0x01, },
1107                 { .hz = 10, .value = 0x02, },
1108                 { .hz = 25, .value = 0x03, },
1109                 { .hz = 50, .value = 0x04, },
1110                 { .hz = 100, .value = 0x05, },
1111                 { .hz = 200, .value = 0x06, },
1112                 { .hz = 400, .value = 0x07, },
1113                 { .hz = 1600, .value = 0x08, },
1114             },
1115         },
1116         .pw = {
1117             .addr = 0x20,
1118             .mask = 0xf0,
1119             .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1120         },
1121         .enable_axis = {
1122             .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1123             .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1124         },
1125         .fs = {
1126             .addr = 0x23,
1127             .mask = 0x30,
1128             .fs_avl = {
1129                 [0] = {
1130                     .num = ST_ACCEL_FS_AVL_2G,
1131                     .value = 0x00,
1132                     .gain = IIO_G_TO_M_S_2(1000),
1133                 },
1134                 [1] = {
1135                     .num = ST_ACCEL_FS_AVL_4G,
1136                     .value = 0x01,
1137                     .gain = IIO_G_TO_M_S_2(2000),
1138                 },
1139                 [2] = {
1140                     .num = ST_ACCEL_FS_AVL_8G,
1141                     .value = 0x02,
1142                     .gain = IIO_G_TO_M_S_2(4000),
1143                 },
1144                 [3] = {
1145                     .num = ST_ACCEL_FS_AVL_16G,
1146                     .value = 0x03,
1147                     .gain = IIO_G_TO_M_S_2(12000),
1148                 },
1149             },
1150         },
1151         .bdu = {
1152             .addr = 0x23,
1153             .mask = 0x80,
1154         },
1155         .drdy_irq = {
1156             .int1 = {
1157                 .addr = 0x22,
1158                 .mask = 0x10,
1159             },
1160             .addr_ihl = 0x25,
1161             .mask_ihl = 0x02,
1162             .stat_drdy = {
1163                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1164                 .mask = 0x07,
1165             },
1166         },
1167         .sim = {
1168             .addr = 0x23,
1169             .value = BIT(0),
1170         },
1171         .multi_read_bit = true,
1172         .bootime = 2,
1173     },
1174 };
1175
1176 /* Default accel DRDY is available on INT1 pin */
1177 static const struct st_sensors_platform_data default_accel_pdata = {
1178     .drdy_int_pin = 1,
1179 };
1180
1181 static int st_accel_read_raw(struct iio_dev *indio_dev,
1182             struct iio_chan_spec const *ch, int *val,
1183                             int *val2, long mask)
1184 {
1185     int err;
1186     struct st_sensor_data *adata = iio_priv(indio_dev);
1187
1188     switch (mask) {
1189     case IIO_CHAN_INFO_RAW:
1190         err = st_sensors_read_info_raw(indio_dev, ch, val);
1191         if (err < 0)
1192             goto read_error;
1193
1194         return IIO_VAL_INT;
1195     case IIO_CHAN_INFO_SCALE:
1196         *val = adata->current_fullscale->gain / 1000000;
1197         *val2 = adata->current_fullscale->gain % 1000000;
1198         return IIO_VAL_INT_PLUS_MICRO;
1199     case IIO_CHAN_INFO_SAMP_FREQ:
1200         *val = adata->odr;
1201         return IIO_VAL_INT;
1202     default:
1203         return -EINVAL;
1204     }
1205
1206 read_error:
1207     return err;
1208 }
1209
1210 static int st_accel_write_raw(struct iio_dev *indio_dev,
1211         struct iio_chan_spec const *chan, int val, int val2, long mask)
1212 {
1213     switch (mask) {
1214     case IIO_CHAN_INFO_SCALE: {
1215         int gain;
1216
1217         gain = val * 1000000 + val2;
1218         return st_sensors_set_fullscale_by_gain(indio_dev, gain);
1219     }
1220     case IIO_CHAN_INFO_SAMP_FREQ:
1221         if (val2)
1222             return -EINVAL;
1223
1224         return st_sensors_set_odr(indio_dev, val);
1225     default:
1226         return -EINVAL;
1227     }
1228 }
1229
1230 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
1231 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
1232
1233 static struct attribute *st_accel_attributes[] = {
1234     &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1235     &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
1236     NULL,
1237 };
1238
1239 static const struct attribute_group st_accel_attribute_group = {
1240     .attrs = st_accel_attributes,
1241 };
1242
1243 static const struct iio_info accel_info = {
1244     .attrs = &st_accel_attribute_group,
1245     .read_raw = &st_accel_read_raw,
1246     .write_raw = &st_accel_write_raw,
1247     .debugfs_reg_access = &st_sensors_debugfs_reg_access,
1248 };
1249
1250 #ifdef CONFIG_IIO_TRIGGER
1251 static const struct iio_trigger_ops st_accel_trigger_ops = {
1252     .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE,
1253     .validate_device = st_sensors_validate_device,
1254 };
1255 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops)
1256 #else
1257 #define ST_ACCEL_TRIGGER_OPS NULL
1258 #endif
1259
1260 #ifdef CONFIG_ACPI
1261 /* Read ST-specific _ONT orientation data from ACPI and generate an
1262  * appropriate mount matrix.
1263  */
1264 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1265 {
1266     struct st_sensor_data *adata = iio_priv(indio_dev);
1267     struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1268     struct acpi_device *adev;
1269     union acpi_object *ont;
1270     union acpi_object *elements;
1271     acpi_status status;
1272     int ret = -EINVAL;
1273     unsigned int val;
1274     int i, j;
1275     int final_ont[3][3] = { { 0 }, };
1276
1277     /* For some reason, ST's _ONT translation does not apply directly
1278      * to the data read from the sensor. Another translation must be
1279      * performed first, as described by the matrix below. Perhaps
1280      * ST required this specific translation for the first product
1281      * where the device was mounted?
1282      */
1283     const int default_ont[3][3] = {
1284         {  0,  1,  0 },
1285         { -1,  0,  0 },
1286         {  0,  0, -1 },
1287     };
1288
1289
1290     adev = ACPI_COMPANION(indio_dev->dev.parent);
1291     if (!adev)
1292         return 0;
1293
1294     /* Read _ONT data, which should be a package of 6 integers. */
1295     status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer);
1296     if (status == AE_NOT_FOUND) {
1297         return 0;
1298     } else if (ACPI_FAILURE(status)) {
1299         dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n",
1300              status);
1301         return status;
1302     }
1303
1304     ont = buffer.pointer;
1305     if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6)
1306         goto out;
1307
1308     /* The first 3 integers provide axis order information.
1309      * e.g. 0 1 2 would indicate normal X,Y,Z ordering.
1310      * e.g. 1 0 2 indicates that data arrives in order Y,X,Z.
1311      */
1312     elements = ont->package.elements;
1313     for (i = 0; i < 3; i++) {
1314         if (elements[i].type != ACPI_TYPE_INTEGER)
1315             goto out;
1316
1317         val = elements[i].integer.value;
1318         if (val > 2)
1319             goto out;
1320
1321         /* Avoiding full matrix multiplication, we simply reorder the
1322          * columns in the default_ont matrix according to the
1323          * ordering provided by _ONT.
1324          */
1325         final_ont[0][i] = default_ont[0][val];
1326         final_ont[1][i] = default_ont[1][val];
1327         final_ont[2][i] = default_ont[2][val];
1328     }
1329
1330     /* The final 3 integers provide sign flip information.
1331      * 0 means no change, 1 means flip.
1332      * e.g. 0 0 1 means that Z data should be sign-flipped.
1333      * This is applied after the axis reordering from above.
1334      */
1335     elements += 3;
1336     for (i = 0; i < 3; i++) {
1337         if (elements[i].type != ACPI_TYPE_INTEGER)
1338             goto out;
1339
1340         val = elements[i].integer.value;
1341         if (val != 0 && val != 1)
1342             goto out;
1343         if (!val)
1344             continue;
1345
1346         /* Flip the values in the indicated column */
1347         final_ont[0][i] *= -1;
1348         final_ont[1][i] *= -1;
1349         final_ont[2][i] *= -1;
1350     }
1351
1352     /* Convert our integer matrix to a string-based iio_mount_matrix */
1353     for (i = 0; i < 3; i++) {
1354         for (j = 0; j < 3; j++) {
1355             int matrix_val = final_ont[i][j];
1356             char *str_value;
1357
1358             switch (matrix_val) {
1359             case -1:
1360                 str_value = "-1";
1361                 break;
1362             case 0:
1363                 str_value = "0";
1364                 break;
1365             case 1:
1366                 str_value = "1";
1367                 break;
1368             default:
1369                 goto out;
1370             }
1371             adata->mount_matrix.rotation[i * 3 + j] = str_value;
1372         }
1373     }
1374
1375     ret = 0;
1376     dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n");
1377
1378 out:
1379     kfree(buffer.pointer);
1380     if (ret)
1381         dev_dbg(&indio_dev->dev,
1382             "failed to apply ACPI orientation data: %d\n", ret);
1383
1384     return ret;
1385 }
1386 #else /* !CONFIG_ACPI */
1387 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1388 {
1389     return -EINVAL;
1390 }
1391 #endif
1392
1393 /*
1394  * st_accel_get_settings() - get sensor settings from device name
1395  * @name: device name buffer reference.
1396  *
1397  * Return: valid reference on success, NULL otherwise.
1398  */
1399 const struct st_sensor_settings *st_accel_get_settings(const char *name)
1400 {
1401     int index = st_sensors_get_settings_index(name,
1402                     st_accel_sensors_settings,
1403                     ARRAY_SIZE(st_accel_sensors_settings));
1404     if (index < 0)
1405         return NULL;
1406
1407     return &st_accel_sensors_settings[index];
1408 }
1409 EXPORT_SYMBOL_NS(st_accel_get_settings, IIO_ST_SENSORS);
1410
1411 int st_accel_common_probe(struct iio_dev *indio_dev)
1412 {
1413     struct st_sensor_data *adata = iio_priv(indio_dev);
1414     struct device *parent = indio_dev->dev.parent;
1415     struct st_sensors_platform_data *pdata = dev_get_platdata(parent);
1416     int err;
1417
1418     indio_dev->modes = INDIO_DIRECT_MODE;
1419     indio_dev->info = &accel_info;
1420
1421     err = st_sensors_verify_id(indio_dev);
1422     if (err < 0)
1423         return err;
1424
1425     adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
1426     indio_dev->channels = adata->sensor_settings->ch;
1427     indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
1428
1429     /*
1430      * First try specific ACPI methods to retrieve orientation then try the
1431      * generic function.
1432      */
1433     err = apply_acpi_orientation(indio_dev);
1434     if (err) {
1435         err = iio_read_mount_matrix(parent, &adata->mount_matrix);
1436         if (err)
1437             return err;
1438     }
1439
1440     adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0];
1441     adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
1442
1443     if (!pdata)
1444         pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
1445
1446     err = st_sensors_init_sensor(indio_dev, pdata);
1447     if (err < 0)
1448         return err;
1449
1450     err = st_accel_allocate_ring(indio_dev);
1451     if (err < 0)
1452         return err;
1453
1454     if (adata->irq > 0) {
1455         err = st_sensors_allocate_trigger(indio_dev,
1456                          ST_ACCEL_TRIGGER_OPS);
1457         if (err < 0)
1458             return err;
1459     }
1460
1461     return devm_iio_device_register(parent, indio_dev);
1462 }
1463 EXPORT_SYMBOL_NS(st_accel_common_probe, IIO_ST_SENSORS);
1464
1465 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
1466 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");
1467 MODULE_LICENSE("GPL v2");
1468 MODULE_IMPORT_NS(IIO_ST_SENSORS);