drivers/iio/accel/st_accel_core.c

   1 /*
   2  * STMicroelectronics accelerometers driver
   3  *
   4  * Copyright 2012-2013 STMicroelectronics Inc.
   5  *
   6  * Denis Ciocca <denis.ciocca@st.com>
   7  *
   8  * Licensed under the GPL-2.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/errno.h>
  15 #include <linux/types.h>
  16 #include <linux/mutex.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/i2c.h>
  19 #include <linux/gpio.h>
  20 #include <linux/irq.h>
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23 #include <linux/iio/trigger.h>
  24 #include <linux/iio/buffer.h>
  25
  26 #include <linux/iio/common/st_sensors.h>
  27 #include "st_accel.h"
  28
  29 #define ST_ACCEL_NUMBER_DATA_CHANNELS           3
  30
  31 /* DEFAULT VALUE FOR SENSORS */
  32 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR           0x28
  33 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR           0x2a
  34 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR           0x2c
  35
  36 /* FULLSCALE */
  37 #define ST_ACCEL_FS_AVL_2G                      2
  38 #define ST_ACCEL_FS_AVL_4G                      4
  39 #define ST_ACCEL_FS_AVL_6G                      6
  40 #define ST_ACCEL_FS_AVL_8G                      8
  41 #define ST_ACCEL_FS_AVL_16G                     16
  42 #define ST_ACCEL_FS_AVL_100G                    100
  43 #define ST_ACCEL_FS_AVL_200G                    200
  44 #define ST_ACCEL_FS_AVL_400G                    400
  45
  46 static const struct iio_chan_spec st_accel_8bit_channels[] = {
  47         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  48                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  49                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
  50                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1),
  51         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  52                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  53                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
  54                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1),
  55         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  56                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  57                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
  58                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1),
  59         IIO_CHAN_SOFT_TIMESTAMP(3)
  60 };
  61
  62 static const struct iio_chan_spec st_accel_12bit_channels[] = {
  63         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  64                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  65                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
  66                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
  67         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  68                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  69                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
  70                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
  71         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  72                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  73                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
  74                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
  75         IIO_CHAN_SOFT_TIMESTAMP(3)
  76 };
  77
  78 static const struct iio_chan_spec st_accel_16bit_channels[] = {
  79         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  80                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  81                         ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
  82                         ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
  83         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  84                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  85                         ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
  86                         ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
  87         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
  88                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  89                         ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
  90                         ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
  91         IIO_CHAN_SOFT_TIMESTAMP(3)
  92 };
  93
  94 static const struct st_sensor_settings st_accel_sensors_settings[] = {
  95         {
  96                 .wai = 0x33,
  97                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
  98                 .sensors_supported = {
  99                         [0] = LIS3DH_ACCEL_DEV_NAME,
 100                         [1] = LSM303DLHC_ACCEL_DEV_NAME,
 101                         [2] = LSM330D_ACCEL_DEV_NAME,
 102                         [3] = LSM330DL_ACCEL_DEV_NAME,
 103                         [4] = LSM330DLC_ACCEL_DEV_NAME,
 104                         [5] = LSM303AGR_ACCEL_DEV_NAME,
 105                         [6] = LIS2DH12_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                         .addr = 0x22,
 163                         .mask_int1 = 0x10,
 164                         .mask_int2 = 0x00,
 165                         .addr_ihl = 0x25,
 166                         .mask_ihl = 0x02,
 167                         .stat_drdy = {
 168                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 169                                 .mask = 0x07,
 170                         },
 171                 },
 172                 .sim = {
 173                         .addr = 0x23,
 174                         .value = BIT(0),
 175                 },
 176                 .multi_read_bit = true,
 177                 .bootime = 2,
 178         },
 179         {
 180                 .wai = 0x32,
 181                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 182                 .sensors_supported = {
 183                         [0] = LIS331DLH_ACCEL_DEV_NAME,
 184                         [1] = LSM303DL_ACCEL_DEV_NAME,
 185                         [2] = LSM303DLH_ACCEL_DEV_NAME,
 186                         [3] = LSM303DLM_ACCEL_DEV_NAME,
 187                 },
 188                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 189                 .odr = {
 190                         .addr = 0x20,
 191                         .mask = 0x18,
 192                         .odr_avl = {
 193                                 { .hz = 50, .value = 0x00, },
 194                                 { .hz = 100, .value = 0x01, },
 195                                 { .hz = 400, .value = 0x02, },
 196                                 { .hz = 1000, .value = 0x03, },
 197                         },
 198                 },
 199                 .pw = {
 200                         .addr = 0x20,
 201                         .mask = 0xe0,
 202                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 203                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 204                 },
 205                 .enable_axis = {
 206                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 207                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 208                 },
 209                 .fs = {
 210                         .addr = 0x23,
 211                         .mask = 0x30,
 212                         .fs_avl = {
 213                                 [0] = {
 214                                         .num = ST_ACCEL_FS_AVL_2G,
 215                                         .value = 0x00,
 216                                         .gain = IIO_G_TO_M_S_2(1000),
 217                                 },
 218                                 [1] = {
 219                                         .num = ST_ACCEL_FS_AVL_4G,
 220                                         .value = 0x01,
 221                                         .gain = IIO_G_TO_M_S_2(2000),
 222                                 },
 223                                 [2] = {
 224                                         .num = ST_ACCEL_FS_AVL_8G,
 225                                         .value = 0x03,
 226                                         .gain = IIO_G_TO_M_S_2(3900),
 227                                 },
 228                         },
 229                 },
 230                 .bdu = {
 231                         .addr = 0x23,
 232                         .mask = 0x80,
 233                 },
 234                 .drdy_irq = {
 235                         .addr = 0x22,
 236                         .mask_int1 = 0x02,
 237                         .mask_int2 = 0x10,
 238                         .addr_ihl = 0x22,
 239                         .mask_ihl = 0x80,
 240                         .addr_od = 0x22,
 241                         .mask_od = 0x40,
 242                         .stat_drdy = {
 243                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 244                                 .mask = 0x07,
 245                         },
 246                 },
 247                 .sim = {
 248                         .addr = 0x23,
 249                         .value = BIT(0),
 250                 },
 251                 .multi_read_bit = true,
 252                 .bootime = 2,
 253         },
 254         {
 255                 .wai = 0x40,
 256                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 257                 .sensors_supported = {
 258                         [0] = LSM330_ACCEL_DEV_NAME,
 259                 },
 260                 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
 261                 .odr = {
 262                         .addr = 0x20,
 263                         .mask = 0xf0,
 264                         .odr_avl = {
 265                                 { .hz = 3, .value = 0x01, },
 266                                 { .hz = 6, .value = 0x02, },
 267                                 { .hz = 12, .value = 0x03, },
 268                                 { .hz = 25, .value = 0x04, },
 269                                 { .hz = 50, .value = 0x05, },
 270                                 { .hz = 100, .value = 0x06, },
 271                                 { .hz = 200, .value = 0x07, },
 272                                 { .hz = 400, .value = 0x08, },
 273                                 { .hz = 800, .value = 0x09, },
 274                                 { .hz = 1600, .value = 0x0a, },
 275                         },
 276                 },
 277                 .pw = {
 278                         .addr = 0x20,
 279                         .mask = 0xf0,
 280                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 281                 },
 282                 .enable_axis = {
 283                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 284                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 285                 },
 286                 .fs = {
 287                         .addr = 0x24,
 288                         .mask = 0x38,
 289                         .fs_avl = {
 290                                 [0] = {
 291                                         .num = ST_ACCEL_FS_AVL_2G,
 292                                         .value = 0x00,
 293                                         .gain = IIO_G_TO_M_S_2(61),
 294                                 },
 295                                 [1] = {
 296                                         .num = ST_ACCEL_FS_AVL_4G,
 297                                         .value = 0x01,
 298                                         .gain = IIO_G_TO_M_S_2(122),
 299                                 },
 300                                 [2] = {
 301                                         .num = ST_ACCEL_FS_AVL_6G,
 302                                         .value = 0x02,
 303                                         .gain = IIO_G_TO_M_S_2(183),
 304                                 },
 305                                 [3] = {
 306                                         .num = ST_ACCEL_FS_AVL_8G,
 307                                         .value = 0x03,
 308                                         .gain = IIO_G_TO_M_S_2(244),
 309                                 },
 310                                 [4] = {
 311                                         .num = ST_ACCEL_FS_AVL_16G,
 312                                         .value = 0x04,
 313                                         .gain = IIO_G_TO_M_S_2(732),
 314                                 },
 315                         },
 316                 },
 317                 .bdu = {
 318                         .addr = 0x20,
 319                         .mask = 0x08,
 320                 },
 321                 .drdy_irq = {
 322                         .addr = 0x23,
 323                         .mask_int1 = 0x80,
 324                         .mask_int2 = 0x00,
 325                         .addr_ihl = 0x23,
 326                         .mask_ihl = 0x40,
 327                         .stat_drdy = {
 328                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 329                                 .mask = 0x07,
 330                         },
 331                         .ig1 = {
 332                                 .en_addr = 0x23,
 333                                 .en_mask = 0x08,
 334                         },
 335                 },
 336                 .sim = {
 337                         .addr = 0x24,
 338                         .value = BIT(0),
 339                 },
 340                 .multi_read_bit = false,
 341                 .bootime = 2,
 342         },
 343         {
 344                 .wai = 0x3a,
 345                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 346                 .sensors_supported = {
 347                         [0] = LIS3LV02DL_ACCEL_DEV_NAME,
 348                 },
 349                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 350                 .odr = {
 351                         .addr = 0x20,
 352                         .mask = 0x30, /* DF1 and DF0 */
 353                         .odr_avl = {
 354                                 { .hz = 40, .value = 0x00, },
 355                                 { .hz = 160, .value = 0x01, },
 356                                 { .hz = 640, .value = 0x02, },
 357                                 { .hz = 2560, .value = 0x03, },
 358                         },
 359                 },
 360                 .pw = {
 361                         .addr = 0x20,
 362                         .mask = 0xc0,
 363                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 364                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 365                 },
 366                 .enable_axis = {
 367                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 368                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 369                 },
 370                 .fs = {
 371                         .addr = 0x21,
 372                         .mask = 0x80,
 373                         .fs_avl = {
 374                                 [0] = {
 375                                         .num = ST_ACCEL_FS_AVL_2G,
 376                                         .value = 0x00,
 377                                         .gain = IIO_G_TO_M_S_2(1000),
 378                                 },
 379                                 [1] = {
 380                                         .num = ST_ACCEL_FS_AVL_6G,
 381                                         .value = 0x01,
 382                                         .gain = IIO_G_TO_M_S_2(3000),
 383                                 },
 384                         },
 385                 },
 386                 .bdu = {
 387                         .addr = 0x21,
 388                         .mask = 0x40,
 389                 },
 390                 /*
 391                  * Data Alignment Setting - needs to be set to get
 392                  * left-justified data like all other sensors.
 393                  */
 394                 .das = {
 395                         .addr = 0x21,
 396                         .mask = 0x01,
 397                 },
 398                 .drdy_irq = {
 399                         .addr = 0x21,
 400                         .mask_int1 = 0x04,
 401                         .stat_drdy = {
 402                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 403                                 .mask = 0x07,
 404                         },
 405                 },
 406                 .sim = {
 407                         .addr = 0x21,
 408                         .value = BIT(1),
 409                 },
 410                 .multi_read_bit = true,
 411                 .bootime = 2, /* guess */
 412         },
 413         {
 414                 .wai = 0x3b,
 415                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 416                 .sensors_supported = {
 417                         [0] = LIS331DL_ACCEL_DEV_NAME,
 418                 },
 419                 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
 420                 .odr = {
 421                         .addr = 0x20,
 422                         .mask = 0x80,
 423                         .odr_avl = {
 424                                 { .hz = 100, .value = 0x00, },
 425                                 { .hz = 400, .value = 0x01, },
 426                         },
 427                 },
 428                 .pw = {
 429                         .addr = 0x20,
 430                         .mask = 0x40,
 431                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 432                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 433                 },
 434                 .enable_axis = {
 435                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 436                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 437                 },
 438                 .fs = {
 439                         .addr = 0x20,
 440                         .mask = 0x20,
 441                         /*
 442                          * TODO: check these resulting gain settings, these are
 443                          * not in the datsheet
 444                          */
 445                         .fs_avl = {
 446                                 [0] = {
 447                                         .num = ST_ACCEL_FS_AVL_2G,
 448                                         .value = 0x00,
 449                                         .gain = IIO_G_TO_M_S_2(18000),
 450                                 },
 451                                 [1] = {
 452                                         .num = ST_ACCEL_FS_AVL_8G,
 453                                         .value = 0x01,
 454                                         .gain = IIO_G_TO_M_S_2(72000),
 455                                 },
 456                         },
 457                 },
 458                 .drdy_irq = {
 459                         .addr = 0x22,
 460                         .mask_int1 = 0x04,
 461                         .mask_int2 = 0x20,
 462                         .addr_ihl = 0x22,
 463                         .mask_ihl = 0x80,
 464                         .addr_od = 0x22,
 465                         .mask_od = 0x40,
 466                         .stat_drdy = {
 467                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 468                                 .mask = 0x07,
 469                         },
 470                 },
 471                 .sim = {
 472                         .addr = 0x21,
 473                         .value = BIT(7),
 474                 },
 475                 .multi_read_bit = false,
 476                 .bootime = 2, /* guess */
 477         },
 478         {
 479                 .wai = 0x32,
 480                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 481                 .sensors_supported = {
 482                         [0] = H3LIS331DL_ACCEL_DEV_NAME,
 483                 },
 484                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 485                 .odr = {
 486                         .addr = 0x20,
 487                         .mask = 0x18,
 488                         .odr_avl = {
 489                                 { .hz = 50, .value = 0x00, },
 490                                 { .hz = 100, .value = 0x01, },
 491                                 { .hz = 400, .value = 0x02, },
 492                                 { .hz = 1000, .value = 0x03, },
 493                         },
 494                 },
 495                 .pw = {
 496                         .addr = 0x20,
 497                         .mask = 0x20,
 498                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 499                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 500                 },
 501                 .enable_axis = {
 502                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 503                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 504                 },
 505                 .fs = {
 506                         .addr = 0x23,
 507                         .mask = 0x30,
 508                         .fs_avl = {
 509                                 [0] = {
 510                                         .num = ST_ACCEL_FS_AVL_100G,
 511                                         .value = 0x00,
 512                                         .gain = IIO_G_TO_M_S_2(49000),
 513                                 },
 514                                 [1] = {
 515                                         .num = ST_ACCEL_FS_AVL_200G,
 516                                         .value = 0x01,
 517                                         .gain = IIO_G_TO_M_S_2(98000),
 518                                 },
 519                                 [2] = {
 520                                         .num = ST_ACCEL_FS_AVL_400G,
 521                                         .value = 0x03,
 522                                         .gain = IIO_G_TO_M_S_2(195000),
 523                                 },
 524                         },
 525                 },
 526                 .bdu = {
 527                         .addr = 0x23,
 528                         .mask = 0x80,
 529                 },
 530                 .drdy_irq = {
 531                         .addr = 0x22,
 532                         .mask_int1 = 0x02,
 533                         .mask_int2 = 0x10,
 534                         .addr_ihl = 0x22,
 535                         .mask_ihl = 0x80,
 536                 },
 537                 .sim = {
 538                         .addr = 0x23,
 539                         .value = BIT(0),
 540                 },
 541                 .multi_read_bit = true,
 542                 .bootime = 2,
 543         },
 544         {
 545                 /* No WAI register present */
 546                 .sensors_supported = {
 547                         [0] = LIS3L02DQ_ACCEL_DEV_NAME,
 548                 },
 549                 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
 550                 .odr = {
 551                         .addr = 0x20,
 552                         .mask = 0x30,
 553                         .odr_avl = {
 554                                 { .hz = 280, .value = 0x00, },
 555                                 { .hz = 560, .value = 0x01, },
 556                                 { .hz = 1120, .value = 0x02, },
 557                                 { .hz = 4480, .value = 0x03, },
 558                         },
 559                 },
 560                 .pw = {
 561                         .addr = 0x20,
 562                         .mask = 0xc0,
 563                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 564                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 565                 },
 566                 .enable_axis = {
 567                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 568                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 569                 },
 570                 .fs = {
 571                         .fs_avl = {
 572                                 [0] = {
 573                                         .num = ST_ACCEL_FS_AVL_2G,
 574                                         .gain = IIO_G_TO_M_S_2(488),
 575                                 },
 576                         },
 577                 },
 578                 /*
 579                  * The part has a BDU bit but if set the data is never
 580                  * updated so don't set it.
 581                  */
 582                 .bdu = {
 583                 },
 584                 .drdy_irq = {
 585                         .addr = 0x21,
 586                         .mask_int1 = 0x04,
 587                         .stat_drdy = {
 588                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 589                                 .mask = 0x07,
 590                         },
 591                 },
 592                 .sim = {
 593                         .addr = 0x21,
 594                         .value = BIT(1),
 595                 },
 596                 .multi_read_bit = false,
 597                 .bootime = 2,
 598         },
 599         {
 600                 .wai = 0x33,
 601                 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
 602                 .sensors_supported = {
 603                         [0] = LNG2DM_ACCEL_DEV_NAME,
 604                 },
 605                 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
 606                 .odr = {
 607                         .addr = 0x20,
 608                         .mask = 0xf0,
 609                         .odr_avl = {
 610                                 { .hz = 1, .value = 0x01, },
 611                                 { .hz = 10, .value = 0x02, },
 612                                 { .hz = 25, .value = 0x03, },
 613                                 { .hz = 50, .value = 0x04, },
 614                                 { .hz = 100, .value = 0x05, },
 615                                 { .hz = 200, .value = 0x06, },
 616                                 { .hz = 400, .value = 0x07, },
 617                                 { .hz = 1600, .value = 0x08, },
 618                         },
 619                 },
 620                 .pw = {
 621                         .addr = 0x20,
 622                         .mask = 0xf0,
 623                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 624                 },
 625                 .enable_axis = {
 626                         .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
 627                         .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
 628                 },
 629                 .fs = {
 630                         .addr = 0x23,
 631                         .mask = 0x30,
 632                         .fs_avl = {
 633                                 [0] = {
 634                                         .num = ST_ACCEL_FS_AVL_2G,
 635                                         .value = 0x00,
 636                                         .gain = IIO_G_TO_M_S_2(15600),
 637                                 },
 638                                 [1] = {
 639                                         .num = ST_ACCEL_FS_AVL_4G,
 640                                         .value = 0x01,
 641                                         .gain = IIO_G_TO_M_S_2(31200),
 642                                 },
 643                                 [2] = {
 644                                         .num = ST_ACCEL_FS_AVL_8G,
 645                                         .value = 0x02,
 646                                         .gain = IIO_G_TO_M_S_2(62500),
 647                                 },
 648                                 [3] = {
 649                                         .num = ST_ACCEL_FS_AVL_16G,
 650                                         .value = 0x03,
 651                                         .gain = IIO_G_TO_M_S_2(187500),
 652                                 },
 653                         },
 654                 },
 655                 .drdy_irq = {
 656                         .addr = 0x22,
 657                         .mask_int1 = 0x10,
 658                         .mask_int2 = 0x00,
 659                         .addr_ihl = 0x25,
 660                         .mask_ihl = 0x02,
 661                         .stat_drdy = {
 662                                 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
 663                                 .mask = 0x07,
 664                         },
 665                 },
 666                 .sim = {
 667                         .addr = 0x23,
 668                         .value = BIT(0),
 669                 },
 670                 .multi_read_bit = true,
 671                 .bootime = 2,
 672         },
 673 };
 674
 675 static int st_accel_read_raw(struct iio_dev *indio_dev,
 676                         struct iio_chan_spec const *ch, int *val,
 677                                                         int *val2, long mask)
 678 {
 679         int err;
 680         struct st_sensor_data *adata = iio_priv(indio_dev);
 681
 682         switch (mask) {
 683         case IIO_CHAN_INFO_RAW:
 684                 err = st_sensors_read_info_raw(indio_dev, ch, val);
 685                 if (err < 0)
 686                         goto read_error;
 687
 688                 return IIO_VAL_INT;
 689         case IIO_CHAN_INFO_SCALE:
 690                 *val = adata->current_fullscale->gain / 1000000;
 691                 *val2 = adata->current_fullscale->gain % 1000000;
 692                 return IIO_VAL_INT_PLUS_MICRO;
 693         case IIO_CHAN_INFO_SAMP_FREQ:
 694                 *val = adata->odr;
 695                 return IIO_VAL_INT;
 696         default:
 697                 return -EINVAL;
 698         }
 699
 700 read_error:
 701         return err;
 702 }
 703
 704 static int st_accel_write_raw(struct iio_dev *indio_dev,
 705                 struct iio_chan_spec const *chan, int val, int val2, long mask)
 706 {
 707         int err;
 708
 709         switch (mask) {
 710         case IIO_CHAN_INFO_SCALE: {
 711                 int gain;
 712
 713                 gain = val * 1000000 + val2;
 714                 err = st_sensors_set_fullscale_by_gain(indio_dev, gain);
 715                 break;
 716         }
 717         case IIO_CHAN_INFO_SAMP_FREQ:
 718                 if (val2)
 719                         return -EINVAL;
 720                 mutex_lock(&indio_dev->mlock);
 721                 err = st_sensors_set_odr(indio_dev, val);
 722                 mutex_unlock(&indio_dev->mlock);
 723                 return err;
 724         default:
 725                 return -EINVAL;
 726         }
 727
 728         return err;
 729 }
 730
 731 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
 732 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
 733
 734 static struct attribute *st_accel_attributes[] = {
 735         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 736         &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
 737         NULL,
 738 };
 739
 740 static const struct attribute_group st_accel_attribute_group = {
 741         .attrs = st_accel_attributes,
 742 };
 743
 744 static const struct iio_info accel_info = {
 745         .driver_module = THIS_MODULE,
 746         .attrs = &st_accel_attribute_group,
 747         .read_raw = &st_accel_read_raw,
 748         .write_raw = &st_accel_write_raw,
 749         .debugfs_reg_access = &st_sensors_debugfs_reg_access,
 750 };
 751
 752 #ifdef CONFIG_IIO_TRIGGER
 753 static const struct iio_trigger_ops st_accel_trigger_ops = {
 754         .owner = THIS_MODULE,
 755         .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE,
 756         .validate_device = st_sensors_validate_device,
 757 };
 758 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops)
 759 #else
 760 #define ST_ACCEL_TRIGGER_OPS NULL
 761 #endif
 762
 763 int st_accel_common_probe(struct iio_dev *indio_dev)
 764 {
 765         struct st_sensor_data *adata = iio_priv(indio_dev);
 766         struct st_sensors_platform_data *pdata =
 767                 (struct st_sensors_platform_data *)adata->dev->platform_data;
 768         int irq = adata->get_irq_data_ready(indio_dev);
 769         int err;
 770
 771         indio_dev->modes = INDIO_DIRECT_MODE;
 772         indio_dev->info = &accel_info;
 773         mutex_init(&adata->tb.buf_lock);
 774
 775         err = st_sensors_power_enable(indio_dev);
 776         if (err)
 777                 return err;
 778
 779         err = st_sensors_check_device_support(indio_dev,
 780                                         ARRAY_SIZE(st_accel_sensors_settings),
 781                                         st_accel_sensors_settings);
 782         if (err < 0)
 783                 goto st_accel_power_off;
 784
 785         adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
 786         adata->multiread_bit = adata->sensor_settings->multi_read_bit;
 787         indio_dev->channels = adata->sensor_settings->ch;
 788         indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
 789
 790         adata->current_fullscale = (struct st_sensor_fullscale_avl *)
 791                                         &adata->sensor_settings->fs.fs_avl[0];
 792         adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
 793
 794         if (!pdata)
 795                 pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
 796
 797         err = st_sensors_init_sensor(indio_dev, pdata);
 798         if (err < 0)
 799                 goto st_accel_power_off;
 800
 801         err = st_accel_allocate_ring(indio_dev);
 802         if (err < 0)
 803                 goto st_accel_power_off;
 804
 805         if (irq > 0) {
 806                 err = st_sensors_allocate_trigger(indio_dev,
 807                                                  ST_ACCEL_TRIGGER_OPS);
 808                 if (err < 0)
 809                         goto st_accel_probe_trigger_error;
 810         }
 811
 812         err = iio_device_register(indio_dev);
 813         if (err)
 814                 goto st_accel_device_register_error;
 815
 816         dev_info(&indio_dev->dev, "registered accelerometer %s\n",
 817                  indio_dev->name);
 818
 819         return 0;
 820
 821 st_accel_device_register_error:
 822         if (irq > 0)
 823                 st_sensors_deallocate_trigger(indio_dev);
 824 st_accel_probe_trigger_error:
 825         st_accel_deallocate_ring(indio_dev);
 826 st_accel_power_off:
 827         st_sensors_power_disable(indio_dev);
 828
 829         return err;
 830 }
 831 EXPORT_SYMBOL(st_accel_common_probe);
 832
 833 void st_accel_common_remove(struct iio_dev *indio_dev)
 834 {
 835         struct st_sensor_data *adata = iio_priv(indio_dev);
 836
 837         st_sensors_power_disable(indio_dev);
 838
 839         iio_device_unregister(indio_dev);
 840         if (adata->get_irq_data_ready(indio_dev) > 0)
 841                 st_sensors_deallocate_trigger(indio_dev);
 842
 843         st_accel_deallocate_ring(indio_dev);
 844 }
 845 EXPORT_SYMBOL(st_accel_common_remove);
 846
 847 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 848 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");
 849 MODULE_LICENSE("GPL v2");