drivers/iio/pressure/st_pressure_core.c

   1 /*
   2  * STMicroelectronics pressures driver
   3  *
   4  * Copyright 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/delay.h>
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/iio/trigger.h>
  25 #include <linux/iio/buffer.h>
  26 #include <linux/regulator/consumer.h>
  27 #include <asm/unaligned.h>
  28
  29 #include <linux/iio/common/st_sensors.h>
  30 #include "st_pressure.h"
  31
  32 #define ST_PRESS_LSB_PER_MBAR                   4096UL
  33 #define ST_PRESS_KPASCAL_NANO_SCALE             (100000000UL / \
  34                                                  ST_PRESS_LSB_PER_MBAR)
  35 #define ST_PRESS_LSB_PER_CELSIUS                480UL
  36 #define ST_PRESS_CELSIUS_NANO_SCALE             (1000000000UL / \
  37                                                  ST_PRESS_LSB_PER_CELSIUS)
  38 #define ST_PRESS_NUMBER_DATA_CHANNELS           1
  39
  40 /* FULLSCALE */
  41 #define ST_PRESS_FS_AVL_1260MB                  1260
  42
  43 #define ST_PRESS_1_OUT_XL_ADDR                  0x28
  44 #define ST_TEMP_1_OUT_L_ADDR                    0x2b
  45
  46 /* CUSTOM VALUES FOR LPS331AP SENSOR */
  47 #define ST_PRESS_LPS331AP_WAI_EXP               0xbb
  48 #define ST_PRESS_LPS331AP_ODR_ADDR              0x20
  49 #define ST_PRESS_LPS331AP_ODR_MASK              0x70
  50 #define ST_PRESS_LPS331AP_ODR_AVL_1HZ_VAL       0x01
  51 #define ST_PRESS_LPS331AP_ODR_AVL_7HZ_VAL       0x05
  52 #define ST_PRESS_LPS331AP_ODR_AVL_13HZ_VAL      0x06
  53 #define ST_PRESS_LPS331AP_ODR_AVL_25HZ_VAL      0x07
  54 #define ST_PRESS_LPS331AP_PW_ADDR               0x20
  55 #define ST_PRESS_LPS331AP_PW_MASK               0x80
  56 #define ST_PRESS_LPS331AP_FS_ADDR               0x23
  57 #define ST_PRESS_LPS331AP_FS_MASK               0x30
  58 #define ST_PRESS_LPS331AP_FS_AVL_1260_VAL       0x00
  59 #define ST_PRESS_LPS331AP_FS_AVL_1260_GAIN      ST_PRESS_KPASCAL_NANO_SCALE
  60 #define ST_PRESS_LPS331AP_FS_AVL_TEMP_GAIN      ST_PRESS_CELSIUS_NANO_SCALE
  61 #define ST_PRESS_LPS331AP_BDU_ADDR              0x20
  62 #define ST_PRESS_LPS331AP_BDU_MASK              0x04
  63 #define ST_PRESS_LPS331AP_DRDY_IRQ_ADDR         0x22
  64 #define ST_PRESS_LPS331AP_DRDY_IRQ_INT1_MASK    0x04
  65 #define ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK    0x20
  66 #define ST_PRESS_LPS331AP_MULTIREAD_BIT         true
  67 #define ST_PRESS_LPS331AP_TEMP_OFFSET           42500
  68
  69 /* CUSTOM VALUES FOR LPS001WP SENSOR */
  70 #define ST_PRESS_LPS001WP_WAI_EXP               0xba
  71 #define ST_PRESS_LPS001WP_ODR_ADDR              0x20
  72 #define ST_PRESS_LPS001WP_ODR_MASK              0x30
  73 #define ST_PRESS_LPS001WP_ODR_AVL_1HZ_VAL       0x01
  74 #define ST_PRESS_LPS001WP_ODR_AVL_7HZ_VAL       0x02
  75 #define ST_PRESS_LPS001WP_ODR_AVL_13HZ_VAL      0x03
  76 #define ST_PRESS_LPS001WP_PW_ADDR               0x20
  77 #define ST_PRESS_LPS001WP_PW_MASK               0x40
  78 #define ST_PRESS_LPS001WP_BDU_ADDR              0x20
  79 #define ST_PRESS_LPS001WP_BDU_MASK              0x04
  80 #define ST_PRESS_LPS001WP_MULTIREAD_BIT         true
  81 #define ST_PRESS_LPS001WP_OUT_L_ADDR            0x28
  82 #define ST_TEMP_LPS001WP_OUT_L_ADDR             0x2a
  83
  84 /* CUSTOM VALUES FOR LPS25H SENSOR */
  85 #define ST_PRESS_LPS25H_WAI_EXP                 0xbd
  86 #define ST_PRESS_LPS25H_ODR_ADDR                0x20
  87 #define ST_PRESS_LPS25H_ODR_MASK                0x70
  88 #define ST_PRESS_LPS25H_ODR_AVL_1HZ_VAL         0x01
  89 #define ST_PRESS_LPS25H_ODR_AVL_7HZ_VAL         0x02
  90 #define ST_PRESS_LPS25H_ODR_AVL_13HZ_VAL        0x03
  91 #define ST_PRESS_LPS25H_ODR_AVL_25HZ_VAL        0x04
  92 #define ST_PRESS_LPS25H_PW_ADDR                 0x20
  93 #define ST_PRESS_LPS25H_PW_MASK                 0x80
  94 #define ST_PRESS_LPS25H_FS_ADDR                 0x00
  95 #define ST_PRESS_LPS25H_FS_MASK                 0x00
  96 #define ST_PRESS_LPS25H_FS_AVL_1260_VAL         0x00
  97 #define ST_PRESS_LPS25H_FS_AVL_1260_GAIN        ST_PRESS_KPASCAL_NANO_SCALE
  98 #define ST_PRESS_LPS25H_FS_AVL_TEMP_GAIN        ST_PRESS_CELSIUS_NANO_SCALE
  99 #define ST_PRESS_LPS25H_BDU_ADDR                0x20
 100 #define ST_PRESS_LPS25H_BDU_MASK                0x04
 101 #define ST_PRESS_LPS25H_DRDY_IRQ_ADDR           0x23
 102 #define ST_PRESS_LPS25H_DRDY_IRQ_INT1_MASK      0x01
 103 #define ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK      0x10
 104 #define ST_PRESS_LPS25H_MULTIREAD_BIT           true
 105 #define ST_PRESS_LPS25H_TEMP_OFFSET             42500
 106 #define ST_PRESS_LPS25H_OUT_XL_ADDR             0x28
 107 #define ST_TEMP_LPS25H_OUT_L_ADDR               0x2b
 108
 109 static const struct iio_chan_spec st_press_1_channels[] = {
 110         {
 111                 .type = IIO_PRESSURE,
 112                 .channel2 = IIO_NO_MOD,
 113                 .address = ST_PRESS_1_OUT_XL_ADDR,
 114                 .scan_index = ST_SENSORS_SCAN_X,
 115                 .scan_type = {
 116                         .sign = 'u',
 117                         .realbits = 24,
 118                         .storagebits = 24,
 119                         .endianness = IIO_LE,
 120                 },
 121                 .info_mask_separate =
 122                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 123                 .modified = 0,
 124         },
 125         {
 126                 .type = IIO_TEMP,
 127                 .channel2 = IIO_NO_MOD,
 128                 .address = ST_TEMP_1_OUT_L_ADDR,
 129                 .scan_index = -1,
 130                 .scan_type = {
 131                         .sign = 'u',
 132                         .realbits = 16,
 133                         .storagebits = 16,
 134                         .endianness = IIO_LE,
 135                 },
 136                 .info_mask_separate =
 137                         BIT(IIO_CHAN_INFO_RAW) |
 138                         BIT(IIO_CHAN_INFO_SCALE) |
 139                         BIT(IIO_CHAN_INFO_OFFSET),
 140                 .modified = 0,
 141         },
 142         IIO_CHAN_SOFT_TIMESTAMP(1)
 143 };
 144
 145 static const struct iio_chan_spec st_press_lps001wp_channels[] = {
 146         {
 147                 .type = IIO_PRESSURE,
 148                 .channel2 = IIO_NO_MOD,
 149                 .address = ST_PRESS_LPS001WP_OUT_L_ADDR,
 150                 .scan_index = ST_SENSORS_SCAN_X,
 151                 .scan_type = {
 152                         .sign = 'u',
 153                         .realbits = 16,
 154                         .storagebits = 16,
 155                         .endianness = IIO_LE,
 156                 },
 157                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 158                 .modified = 0,
 159         },
 160         {
 161                 .type = IIO_TEMP,
 162                 .channel2 = IIO_NO_MOD,
 163                 .address = ST_TEMP_LPS001WP_OUT_L_ADDR,
 164                 .scan_index = -1,
 165                 .scan_type = {
 166                         .sign = 'u',
 167                         .realbits = 16,
 168                         .storagebits = 16,
 169                         .endianness = IIO_LE,
 170                 },
 171                 .info_mask_separate =
 172                         BIT(IIO_CHAN_INFO_RAW) |
 173                         BIT(IIO_CHAN_INFO_OFFSET),
 174                 .modified = 0,
 175         },
 176         IIO_CHAN_SOFT_TIMESTAMP(1)
 177 };
 178
 179 static const struct st_sensors st_press_sensors[] = {
 180         {
 181                 .wai = ST_PRESS_LPS331AP_WAI_EXP,
 182                 .sensors_supported = {
 183                         [0] = LPS331AP_PRESS_DEV_NAME,
 184                 },
 185                 .ch = (struct iio_chan_spec *)st_press_1_channels,
 186                 .num_ch = ARRAY_SIZE(st_press_1_channels),
 187                 .odr = {
 188                         .addr = ST_PRESS_LPS331AP_ODR_ADDR,
 189                         .mask = ST_PRESS_LPS331AP_ODR_MASK,
 190                         .odr_avl = {
 191                                 { 1, ST_PRESS_LPS331AP_ODR_AVL_1HZ_VAL, },
 192                                 { 7, ST_PRESS_LPS331AP_ODR_AVL_7HZ_VAL, },
 193                                 { 13, ST_PRESS_LPS331AP_ODR_AVL_13HZ_VAL, },
 194                                 { 25, ST_PRESS_LPS331AP_ODR_AVL_25HZ_VAL, },
 195                         },
 196                 },
 197                 .pw = {
 198                         .addr = ST_PRESS_LPS331AP_PW_ADDR,
 199                         .mask = ST_PRESS_LPS331AP_PW_MASK,
 200                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 201                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 202                 },
 203                 .fs = {
 204                         .addr = ST_PRESS_LPS331AP_FS_ADDR,
 205                         .mask = ST_PRESS_LPS331AP_FS_MASK,
 206                         .fs_avl = {
 207                                 [0] = {
 208                                         .num = ST_PRESS_FS_AVL_1260MB,
 209                                         .value = ST_PRESS_LPS331AP_FS_AVL_1260_VAL,
 210                                         .gain = ST_PRESS_LPS331AP_FS_AVL_1260_GAIN,
 211                                         .gain2 = ST_PRESS_LPS331AP_FS_AVL_TEMP_GAIN,
 212                                 },
 213                         },
 214                 },
 215                 .bdu = {
 216                         .addr = ST_PRESS_LPS331AP_BDU_ADDR,
 217                         .mask = ST_PRESS_LPS331AP_BDU_MASK,
 218                 },
 219                 .drdy_irq = {
 220                         .addr = ST_PRESS_LPS331AP_DRDY_IRQ_ADDR,
 221                         .mask_int1 = ST_PRESS_LPS331AP_DRDY_IRQ_INT1_MASK,
 222                         .mask_int2 = ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK,
 223                 },
 224                 .multi_read_bit = ST_PRESS_LPS331AP_MULTIREAD_BIT,
 225                 .bootime = 2,
 226         },
 227         {
 228                 .wai = ST_PRESS_LPS001WP_WAI_EXP,
 229                 .sensors_supported = {
 230                         [0] = LPS001WP_PRESS_DEV_NAME,
 231                 },
 232                 .ch = (struct iio_chan_spec *)st_press_lps001wp_channels,
 233                 .num_ch = ARRAY_SIZE(st_press_lps001wp_channels),
 234                 .odr = {
 235                         .addr = ST_PRESS_LPS001WP_ODR_ADDR,
 236                         .mask = ST_PRESS_LPS001WP_ODR_MASK,
 237                         .odr_avl = {
 238                                 { 1, ST_PRESS_LPS001WP_ODR_AVL_1HZ_VAL, },
 239                                 { 7, ST_PRESS_LPS001WP_ODR_AVL_7HZ_VAL, },
 240                                 { 13, ST_PRESS_LPS001WP_ODR_AVL_13HZ_VAL, },
 241                         },
 242                 },
 243                 .pw = {
 244                         .addr = ST_PRESS_LPS001WP_PW_ADDR,
 245                         .mask = ST_PRESS_LPS001WP_PW_MASK,
 246                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 247                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 248                 },
 249                 .fs = {
 250                         .addr = 0,
 251                 },
 252                 .bdu = {
 253                         .addr = ST_PRESS_LPS001WP_BDU_ADDR,
 254                         .mask = ST_PRESS_LPS001WP_BDU_MASK,
 255                 },
 256                 .drdy_irq = {
 257                         .addr = 0,
 258                 },
 259                 .multi_read_bit = ST_PRESS_LPS001WP_MULTIREAD_BIT,
 260                 .bootime = 2,
 261         },
 262         {
 263                 .wai = ST_PRESS_LPS25H_WAI_EXP,
 264                 .sensors_supported = {
 265                         [0] = LPS25H_PRESS_DEV_NAME,
 266                 },
 267                 .ch = (struct iio_chan_spec *)st_press_1_channels,
 268                 .num_ch = ARRAY_SIZE(st_press_1_channels),
 269                 .odr = {
 270                         .addr = ST_PRESS_LPS25H_ODR_ADDR,
 271                         .mask = ST_PRESS_LPS25H_ODR_MASK,
 272                         .odr_avl = {
 273                                 { 1, ST_PRESS_LPS25H_ODR_AVL_1HZ_VAL, },
 274                                 { 7, ST_PRESS_LPS25H_ODR_AVL_7HZ_VAL, },
 275                                 { 13, ST_PRESS_LPS25H_ODR_AVL_13HZ_VAL, },
 276                                 { 25, ST_PRESS_LPS25H_ODR_AVL_25HZ_VAL, },
 277                         },
 278                 },
 279                 .pw = {
 280                         .addr = ST_PRESS_LPS25H_PW_ADDR,
 281                         .mask = ST_PRESS_LPS25H_PW_MASK,
 282                         .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
 283                         .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
 284                 },
 285                 .fs = {
 286                         .addr = ST_PRESS_LPS25H_FS_ADDR,
 287                         .mask = ST_PRESS_LPS25H_FS_MASK,
 288                         .fs_avl = {
 289                                 [0] = {
 290                                         .num = ST_PRESS_FS_AVL_1260MB,
 291                                         .value = ST_PRESS_LPS25H_FS_AVL_1260_VAL,
 292                                         .gain = ST_PRESS_LPS25H_FS_AVL_1260_GAIN,
 293                                         .gain2 = ST_PRESS_LPS25H_FS_AVL_TEMP_GAIN,
 294                                 },
 295                         },
 296                 },
 297                 .bdu = {
 298                         .addr = ST_PRESS_LPS25H_BDU_ADDR,
 299                         .mask = ST_PRESS_LPS25H_BDU_MASK,
 300                 },
 301                 .drdy_irq = {
 302                         .addr = ST_PRESS_LPS25H_DRDY_IRQ_ADDR,
 303                         .mask_int1 = ST_PRESS_LPS25H_DRDY_IRQ_INT1_MASK,
 304                         .mask_int2 = ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK,
 305                 },
 306                 .multi_read_bit = ST_PRESS_LPS25H_MULTIREAD_BIT,
 307                 .bootime = 2,
 308         },
 309 };
 310
 311 static int st_press_read_raw(struct iio_dev *indio_dev,
 312                         struct iio_chan_spec const *ch, int *val,
 313                                                         int *val2, long mask)
 314 {
 315         int err;
 316         struct st_sensor_data *pdata = iio_priv(indio_dev);
 317
 318         switch (mask) {
 319         case IIO_CHAN_INFO_RAW:
 320                 err = st_sensors_read_info_raw(indio_dev, ch, val);
 321                 if (err < 0)
 322                         goto read_error;
 323
 324                 return IIO_VAL_INT;
 325         case IIO_CHAN_INFO_SCALE:
 326                 *val = 0;
 327
 328                 switch (ch->type) {
 329                 case IIO_PRESSURE:
 330                         *val2 = pdata->current_fullscale->gain;
 331                         break;
 332                 case IIO_TEMP:
 333                         *val2 = pdata->current_fullscale->gain2;
 334                         break;
 335                 default:
 336                         err = -EINVAL;
 337                         goto read_error;
 338                 }
 339
 340                 return IIO_VAL_INT_PLUS_NANO;
 341         case IIO_CHAN_INFO_OFFSET:
 342                 switch (ch->type) {
 343                 case IIO_TEMP:
 344                         *val = 425;
 345                         *val2 = 10;
 346                         break;
 347                 default:
 348                         err = -EINVAL;
 349                         goto read_error;
 350                 }
 351
 352                 return IIO_VAL_FRACTIONAL;
 353         default:
 354                 return -EINVAL;
 355         }
 356
 357 read_error:
 358         return err;
 359 }
 360
 361 static ST_SENSOR_DEV_ATTR_SAMP_FREQ();
 362 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
 363
 364 static struct attribute *st_press_attributes[] = {
 365         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 366         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 367         NULL,
 368 };
 369
 370 static const struct attribute_group st_press_attribute_group = {
 371         .attrs = st_press_attributes,
 372 };
 373
 374 static const struct iio_info press_info = {
 375         .driver_module = THIS_MODULE,
 376         .attrs = &st_press_attribute_group,
 377         .read_raw = &st_press_read_raw,
 378 };
 379
 380 #ifdef CONFIG_IIO_TRIGGER
 381 static const struct iio_trigger_ops st_press_trigger_ops = {
 382         .owner = THIS_MODULE,
 383         .set_trigger_state = ST_PRESS_TRIGGER_SET_STATE,
 384 };
 385 #define ST_PRESS_TRIGGER_OPS (&st_press_trigger_ops)
 386 #else
 387 #define ST_PRESS_TRIGGER_OPS NULL
 388 #endif
 389
 390 static void st_press_power_enable(struct iio_dev *indio_dev)
 391 {
 392         struct st_sensor_data *pdata = iio_priv(indio_dev);
 393         int err;
 394
 395         /* Regulators not mandatory, but if requested we should enable them. */
 396         pdata->vdd = devm_regulator_get_optional(&indio_dev->dev, "vdd");
 397         if (!IS_ERR(pdata->vdd)) {
 398                 err = regulator_enable(pdata->vdd);
 399                 if (err != 0)
 400                         dev_warn(&indio_dev->dev,
 401                                  "Failed to enable specified Vdd supply\n");
 402         }
 403
 404         pdata->vdd_io = devm_regulator_get_optional(&indio_dev->dev, "vddio");
 405         if (!IS_ERR(pdata->vdd_io)) {
 406                 err = regulator_enable(pdata->vdd_io);
 407                 if (err != 0)
 408                         dev_warn(&indio_dev->dev,
 409                                  "Failed to enable specified Vdd_IO supply\n");
 410         }
 411 }
 412
 413 static void st_press_power_disable(struct iio_dev *indio_dev)
 414 {
 415         struct st_sensor_data *pdata = iio_priv(indio_dev);
 416
 417         if (!IS_ERR(pdata->vdd))
 418                 regulator_disable(pdata->vdd);
 419
 420         if (!IS_ERR(pdata->vdd_io))
 421                 regulator_disable(pdata->vdd_io);
 422 }
 423
 424 int st_press_common_probe(struct iio_dev *indio_dev,
 425                                 struct st_sensors_platform_data *plat_data)
 426 {
 427         struct st_sensor_data *pdata = iio_priv(indio_dev);
 428         int irq = pdata->get_irq_data_ready(indio_dev);
 429         int err;
 430
 431         indio_dev->modes = INDIO_DIRECT_MODE;
 432         indio_dev->info = &press_info;
 433
 434         st_press_power_enable(indio_dev);
 435
 436         err = st_sensors_check_device_support(indio_dev,
 437                                               ARRAY_SIZE(st_press_sensors),
 438                                               st_press_sensors);
 439         if (err < 0)
 440                 return err;
 441
 442         pdata->num_data_channels = ST_PRESS_NUMBER_DATA_CHANNELS;
 443         pdata->multiread_bit     = pdata->sensor->multi_read_bit;
 444         indio_dev->channels      = pdata->sensor->ch;
 445         indio_dev->num_channels  = pdata->sensor->num_ch;
 446
 447         if (pdata->sensor->fs.addr != 0)
 448                 pdata->current_fullscale = (struct st_sensor_fullscale_avl *)
 449                         &pdata->sensor->fs.fs_avl[0];
 450
 451         pdata->odr = pdata->sensor->odr.odr_avl[0].hz;
 452
 453         /* Some devices don't support a data ready pin. */
 454         if (!plat_data && pdata->sensor->drdy_irq.addr)
 455                 plat_data =
 456                         (struct st_sensors_platform_data *)&default_press_pdata;
 457
 458         err = st_sensors_init_sensor(indio_dev, plat_data);
 459         if (err < 0)
 460                 return err;
 461
 462         err = st_press_allocate_ring(indio_dev);
 463         if (err < 0)
 464                 return err;
 465
 466         if (irq > 0) {
 467                 err = st_sensors_allocate_trigger(indio_dev,
 468                                                   ST_PRESS_TRIGGER_OPS);
 469                 if (err < 0)
 470                         goto st_press_probe_trigger_error;
 471         }
 472
 473         err = iio_device_register(indio_dev);
 474         if (err)
 475                 goto st_press_device_register_error;
 476
 477         return err;
 478
 479 st_press_device_register_error:
 480         if (irq > 0)
 481                 st_sensors_deallocate_trigger(indio_dev);
 482 st_press_probe_trigger_error:
 483         st_press_deallocate_ring(indio_dev);
 484
 485         return err;
 486 }
 487 EXPORT_SYMBOL(st_press_common_probe);
 488
 489 void st_press_common_remove(struct iio_dev *indio_dev)
 490 {
 491         struct st_sensor_data *pdata = iio_priv(indio_dev);
 492
 493         st_press_power_disable(indio_dev);
 494
 495         iio_device_unregister(indio_dev);
 496         if (pdata->get_irq_data_ready(indio_dev) > 0)
 497                 st_sensors_deallocate_trigger(indio_dev);
 498
 499         st_press_deallocate_ring(indio_dev);
 500 }
 501 EXPORT_SYMBOL(st_press_common_remove);
 502
 503 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 504 MODULE_DESCRIPTION("STMicroelectronics pressures driver");
 505 MODULE_LICENSE("GPL v2");