drivers/iio/common/st_sensors/st_sensors_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * STMicroelectronics sensors core library driver
   4  *
   5  * Copyright 2012-2013 STMicroelectronics Inc.
   6  *
   7  * Denis Ciocca <denis.ciocca@st.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/delay.h>
  14 #include <linux/iio/iio.h>
  15 #include <linux/property.h>
  16 #include <linux/regulator/consumer.h>
  17 #include <linux/regmap.h>
  18 #include <asm/unaligned.h>
  19 #include <linux/iio/common/st_sensors.h>
  20
  21 #include "st_sensors_core.h"
  22
  23 static inline u32 st_sensors_get_unaligned_le24(const u8 *p)
  24 {
  25         return (s32)((p[0] | p[1] << 8 | p[2] << 16) << 8) >> 8;
  26 }
  27
  28 int st_sensors_write_data_with_mask(struct iio_dev *indio_dev,
  29                                     u8 reg_addr, u8 mask, u8 data)
  30 {
  31         struct st_sensor_data *sdata = iio_priv(indio_dev);
  32
  33         return regmap_update_bits(sdata->regmap,
  34                                   reg_addr, mask, data << __ffs(mask));
  35 }
  36
  37 int st_sensors_debugfs_reg_access(struct iio_dev *indio_dev,
  38                                   unsigned reg, unsigned writeval,
  39                                   unsigned *readval)
  40 {
  41         struct st_sensor_data *sdata = iio_priv(indio_dev);
  42         int err;
  43
  44         if (!readval)
  45                 return regmap_write(sdata->regmap, reg, writeval);
  46
  47         err = regmap_read(sdata->regmap, reg, readval);
  48         if (err < 0)
  49                 return err;
  50
  51         return 0;
  52 }
  53 EXPORT_SYMBOL(st_sensors_debugfs_reg_access);
  54
  55 static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
  56                         unsigned int odr, struct st_sensor_odr_avl *odr_out)
  57 {
  58         int i, ret = -EINVAL;
  59
  60         for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
  61                 if (sensor_settings->odr.odr_avl[i].hz == 0)
  62                         goto st_sensors_match_odr_error;
  63
  64                 if (sensor_settings->odr.odr_avl[i].hz == odr) {
  65                         odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
  66                         odr_out->value = sensor_settings->odr.odr_avl[i].value;
  67                         ret = 0;
  68                         break;
  69                 }
  70         }
  71
  72 st_sensors_match_odr_error:
  73         return ret;
  74 }
  75
  76 int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
  77 {
  78         int err;
  79         struct st_sensor_odr_avl odr_out = {0, 0};
  80         struct st_sensor_data *sdata = iio_priv(indio_dev);
  81
  82         if (!sdata->sensor_settings->odr.mask)
  83                 return 0;
  84
  85         err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
  86         if (err < 0)
  87                 goto st_sensors_match_odr_error;
  88
  89         if ((sdata->sensor_settings->odr.addr ==
  90                                         sdata->sensor_settings->pw.addr) &&
  91                                 (sdata->sensor_settings->odr.mask ==
  92                                         sdata->sensor_settings->pw.mask)) {
  93                 if (sdata->enabled == true) {
  94                         err = st_sensors_write_data_with_mask(indio_dev,
  95                                 sdata->sensor_settings->odr.addr,
  96                                 sdata->sensor_settings->odr.mask,
  97                                 odr_out.value);
  98                 } else {
  99                         err = 0;
 100                 }
 101         } else {
 102                 err = st_sensors_write_data_with_mask(indio_dev,
 103                         sdata->sensor_settings->odr.addr,
 104                         sdata->sensor_settings->odr.mask,
 105                         odr_out.value);
 106         }
 107         if (err >= 0)
 108                 sdata->odr = odr_out.hz;
 109
 110 st_sensors_match_odr_error:
 111         return err;
 112 }
 113 EXPORT_SYMBOL(st_sensors_set_odr);
 114
 115 static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
 116                                         unsigned int fs, int *index_fs_avl)
 117 {
 118         int i, ret = -EINVAL;
 119
 120         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
 121                 if (sensor_settings->fs.fs_avl[i].num == 0)
 122                         return ret;
 123
 124                 if (sensor_settings->fs.fs_avl[i].num == fs) {
 125                         *index_fs_avl = i;
 126                         ret = 0;
 127                         break;
 128                 }
 129         }
 130
 131         return ret;
 132 }
 133
 134 static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
 135 {
 136         int err, i = 0;
 137         struct st_sensor_data *sdata = iio_priv(indio_dev);
 138
 139         if (sdata->sensor_settings->fs.addr == 0)
 140                 return 0;
 141
 142         err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
 143         if (err < 0)
 144                 goto st_accel_set_fullscale_error;
 145
 146         err = st_sensors_write_data_with_mask(indio_dev,
 147                                 sdata->sensor_settings->fs.addr,
 148                                 sdata->sensor_settings->fs.mask,
 149                                 sdata->sensor_settings->fs.fs_avl[i].value);
 150         if (err < 0)
 151                 goto st_accel_set_fullscale_error;
 152
 153         sdata->current_fullscale = (struct st_sensor_fullscale_avl *)
 154                                         &sdata->sensor_settings->fs.fs_avl[i];
 155         return err;
 156
 157 st_accel_set_fullscale_error:
 158         dev_err(&indio_dev->dev, "failed to set new fullscale.\n");
 159         return err;
 160 }
 161
 162 int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
 163 {
 164         u8 tmp_value;
 165         int err = -EINVAL;
 166         bool found = false;
 167         struct st_sensor_odr_avl odr_out = {0, 0};
 168         struct st_sensor_data *sdata = iio_priv(indio_dev);
 169
 170         if (enable) {
 171                 tmp_value = sdata->sensor_settings->pw.value_on;
 172                 if ((sdata->sensor_settings->odr.addr ==
 173                                         sdata->sensor_settings->pw.addr) &&
 174                                 (sdata->sensor_settings->odr.mask ==
 175                                         sdata->sensor_settings->pw.mask)) {
 176                         err = st_sensors_match_odr(sdata->sensor_settings,
 177                                                         sdata->odr, &odr_out);
 178                         if (err < 0)
 179                                 goto set_enable_error;
 180                         tmp_value = odr_out.value;
 181                         found = true;
 182                 }
 183                 err = st_sensors_write_data_with_mask(indio_dev,
 184                                 sdata->sensor_settings->pw.addr,
 185                                 sdata->sensor_settings->pw.mask, tmp_value);
 186                 if (err < 0)
 187                         goto set_enable_error;
 188
 189                 sdata->enabled = true;
 190
 191                 if (found)
 192                         sdata->odr = odr_out.hz;
 193         } else {
 194                 err = st_sensors_write_data_with_mask(indio_dev,
 195                                 sdata->sensor_settings->pw.addr,
 196                                 sdata->sensor_settings->pw.mask,
 197                                 sdata->sensor_settings->pw.value_off);
 198                 if (err < 0)
 199                         goto set_enable_error;
 200
 201                 sdata->enabled = false;
 202         }
 203
 204 set_enable_error:
 205         return err;
 206 }
 207 EXPORT_SYMBOL(st_sensors_set_enable);
 208
 209 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
 210 {
 211         struct st_sensor_data *sdata = iio_priv(indio_dev);
 212         int err = 0;
 213
 214         if (sdata->sensor_settings->enable_axis.addr)
 215                 err = st_sensors_write_data_with_mask(indio_dev,
 216                                 sdata->sensor_settings->enable_axis.addr,
 217                                 sdata->sensor_settings->enable_axis.mask,
 218                                 axis_enable);
 219         return err;
 220 }
 221 EXPORT_SYMBOL(st_sensors_set_axis_enable);
 222
 223 int st_sensors_power_enable(struct iio_dev *indio_dev)
 224 {
 225         struct st_sensor_data *pdata = iio_priv(indio_dev);
 226         int err;
 227
 228         /* Regulators not mandatory, but if requested we should enable them. */
 229         pdata->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
 230         if (IS_ERR(pdata->vdd)) {
 231                 dev_err(&indio_dev->dev, "unable to get Vdd supply\n");
 232                 return PTR_ERR(pdata->vdd);
 233         }
 234         err = regulator_enable(pdata->vdd);
 235         if (err != 0) {
 236                 dev_warn(&indio_dev->dev,
 237                          "Failed to enable specified Vdd supply\n");
 238                 return err;
 239         }
 240
 241         pdata->vdd_io = devm_regulator_get(indio_dev->dev.parent, "vddio");
 242         if (IS_ERR(pdata->vdd_io)) {
 243                 dev_err(&indio_dev->dev, "unable to get Vdd_IO supply\n");
 244                 err = PTR_ERR(pdata->vdd_io);
 245                 goto st_sensors_disable_vdd;
 246         }
 247         err = regulator_enable(pdata->vdd_io);
 248         if (err != 0) {
 249                 dev_warn(&indio_dev->dev,
 250                          "Failed to enable specified Vdd_IO supply\n");
 251                 goto st_sensors_disable_vdd;
 252         }
 253
 254         return 0;
 255
 256 st_sensors_disable_vdd:
 257         regulator_disable(pdata->vdd);
 258         return err;
 259 }
 260 EXPORT_SYMBOL(st_sensors_power_enable);
 261
 262 void st_sensors_power_disable(struct iio_dev *indio_dev)
 263 {
 264         struct st_sensor_data *pdata = iio_priv(indio_dev);
 265
 266         regulator_disable(pdata->vdd);
 267         regulator_disable(pdata->vdd_io);
 268 }
 269 EXPORT_SYMBOL(st_sensors_power_disable);
 270
 271 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
 272                                         struct st_sensors_platform_data *pdata)
 273 {
 274         struct st_sensor_data *sdata = iio_priv(indio_dev);
 275
 276         /* Sensor does not support interrupts */
 277         if (!sdata->sensor_settings->drdy_irq.int1.addr &&
 278             !sdata->sensor_settings->drdy_irq.int2.addr) {
 279                 if (pdata->drdy_int_pin)
 280                         dev_info(&indio_dev->dev,
 281                                  "DRDY on pin INT%d specified, but sensor "
 282                                  "does not support interrupts\n",
 283                                  pdata->drdy_int_pin);
 284                 return 0;
 285         }
 286
 287         switch (pdata->drdy_int_pin) {
 288         case 1:
 289                 if (!sdata->sensor_settings->drdy_irq.int1.mask) {
 290                         dev_err(&indio_dev->dev,
 291                                         "DRDY on INT1 not available.\n");
 292                         return -EINVAL;
 293                 }
 294                 sdata->drdy_int_pin = 1;
 295                 break;
 296         case 2:
 297                 if (!sdata->sensor_settings->drdy_irq.int2.mask) {
 298                         dev_err(&indio_dev->dev,
 299                                         "DRDY on INT2 not available.\n");
 300                         return -EINVAL;
 301                 }
 302                 sdata->drdy_int_pin = 2;
 303                 break;
 304         default:
 305                 dev_err(&indio_dev->dev, "DRDY on pdata not valid.\n");
 306                 return -EINVAL;
 307         }
 308
 309         if (pdata->open_drain) {
 310                 if (!sdata->sensor_settings->drdy_irq.int1.addr_od &&
 311                     !sdata->sensor_settings->drdy_irq.int2.addr_od)
 312                         dev_err(&indio_dev->dev,
 313                                 "open drain requested but unsupported.\n");
 314                 else
 315                         sdata->int_pin_open_drain = true;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static struct st_sensors_platform_data *st_sensors_dev_probe(struct device *dev,
 322                 struct st_sensors_platform_data *defdata)
 323 {
 324         struct st_sensors_platform_data *pdata;
 325         u32 val;
 326
 327         if (!dev_fwnode(dev))
 328                 return NULL;
 329
 330         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 331         if (!pdata)
 332                 return ERR_PTR(-ENOMEM);
 333         if (!device_property_read_u32(dev, "st,drdy-int-pin", &val) && (val <= 2))
 334                 pdata->drdy_int_pin = (u8) val;
 335         else
 336                 pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
 337
 338         pdata->open_drain = device_property_read_bool(dev, "drive-open-drain");
 339
 340         return pdata;
 341 }
 342
 343 /**
 344  * st_sensors_dev_name_probe() - device probe for ST sensor name
 345  * @dev: driver model representation of the device.
 346  * @name: device name buffer reference.
 347  * @len: device name buffer length.
 348  *
 349  * In effect this function matches an ID to an internal kernel
 350  * name for a certain sensor device, so that the rest of the autodetection can
 351  * rely on that name from this point on. I2C/SPI devices will be renamed
 352  * to match the internal kernel convention.
 353  */
 354 void st_sensors_dev_name_probe(struct device *dev, char *name, int len)
 355 {
 356         const void *match;
 357
 358         match = device_get_match_data(dev);
 359         if (!match)
 360                 return;
 361
 362         /* The name from the match takes precedence if present */
 363         strlcpy(name, match, len);
 364 }
 365 EXPORT_SYMBOL(st_sensors_dev_name_probe);
 366
 367 int st_sensors_init_sensor(struct iio_dev *indio_dev,
 368                                         struct st_sensors_platform_data *pdata)
 369 {
 370         struct st_sensor_data *sdata = iio_priv(indio_dev);
 371         struct st_sensors_platform_data *of_pdata;
 372         int err = 0;
 373
 374         /* If OF/DT pdata exists, it will take precedence of anything else */
 375         of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata);
 376         if (IS_ERR(of_pdata))
 377                 return PTR_ERR(of_pdata);
 378         if (of_pdata)
 379                 pdata = of_pdata;
 380
 381         if (pdata) {
 382                 err = st_sensors_set_drdy_int_pin(indio_dev, pdata);
 383                 if (err < 0)
 384                         return err;
 385         }
 386
 387         err = st_sensors_set_enable(indio_dev, false);
 388         if (err < 0)
 389                 return err;
 390
 391         /* Disable DRDY, this might be still be enabled after reboot. */
 392         err = st_sensors_set_dataready_irq(indio_dev, false);
 393         if (err < 0)
 394                 return err;
 395
 396         if (sdata->current_fullscale) {
 397                 err = st_sensors_set_fullscale(indio_dev,
 398                                                 sdata->current_fullscale->num);
 399                 if (err < 0)
 400                         return err;
 401         } else
 402                 dev_info(&indio_dev->dev, "Full-scale not possible\n");
 403
 404         err = st_sensors_set_odr(indio_dev, sdata->odr);
 405         if (err < 0)
 406                 return err;
 407
 408         /* set BDU */
 409         if (sdata->sensor_settings->bdu.addr) {
 410                 err = st_sensors_write_data_with_mask(indio_dev,
 411                                         sdata->sensor_settings->bdu.addr,
 412                                         sdata->sensor_settings->bdu.mask, true);
 413                 if (err < 0)
 414                         return err;
 415         }
 416
 417         /* set DAS */
 418         if (sdata->sensor_settings->das.addr) {
 419                 err = st_sensors_write_data_with_mask(indio_dev,
 420                                         sdata->sensor_settings->das.addr,
 421                                         sdata->sensor_settings->das.mask, 1);
 422                 if (err < 0)
 423                         return err;
 424         }
 425
 426         if (sdata->int_pin_open_drain) {
 427                 u8 addr, mask;
 428
 429                 if (sdata->drdy_int_pin == 1) {
 430                         addr = sdata->sensor_settings->drdy_irq.int1.addr_od;
 431                         mask = sdata->sensor_settings->drdy_irq.int1.mask_od;
 432                 } else {
 433                         addr = sdata->sensor_settings->drdy_irq.int2.addr_od;
 434                         mask = sdata->sensor_settings->drdy_irq.int2.mask_od;
 435                 }
 436
 437                 dev_info(&indio_dev->dev,
 438                          "set interrupt line to open drain mode on pin %d\n",
 439                          sdata->drdy_int_pin);
 440                 err = st_sensors_write_data_with_mask(indio_dev, addr,
 441                                                       mask, 1);
 442                 if (err < 0)
 443                         return err;
 444         }
 445
 446         err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
 447
 448         return err;
 449 }
 450 EXPORT_SYMBOL(st_sensors_init_sensor);
 451
 452 int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
 453 {
 454         int err;
 455         u8 drdy_addr, drdy_mask;
 456         struct st_sensor_data *sdata = iio_priv(indio_dev);
 457
 458         if (!sdata->sensor_settings->drdy_irq.int1.addr &&
 459             !sdata->sensor_settings->drdy_irq.int2.addr) {
 460                 /*
 461                  * there are some devices (e.g. LIS3MDL) where drdy line is
 462                  * routed to a given pin and it is not possible to select a
 463                  * different one. Take into account irq status register
 464                  * to understand if irq trigger can be properly supported
 465                  */
 466                 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr)
 467                         sdata->hw_irq_trigger = enable;
 468                 return 0;
 469         }
 470
 471         /* Enable/Disable the interrupt generator 1. */
 472         if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
 473                 err = st_sensors_write_data_with_mask(indio_dev,
 474                                 sdata->sensor_settings->drdy_irq.ig1.en_addr,
 475                                 sdata->sensor_settings->drdy_irq.ig1.en_mask,
 476                                 (int)enable);
 477                 if (err < 0)
 478                         goto st_accel_set_dataready_irq_error;
 479         }
 480
 481         if (sdata->drdy_int_pin == 1) {
 482                 drdy_addr = sdata->sensor_settings->drdy_irq.int1.addr;
 483                 drdy_mask = sdata->sensor_settings->drdy_irq.int1.mask;
 484         } else {
 485                 drdy_addr = sdata->sensor_settings->drdy_irq.int2.addr;
 486                 drdy_mask = sdata->sensor_settings->drdy_irq.int2.mask;
 487         }
 488
 489         /* Flag to the poll function that the hardware trigger is in use */
 490         sdata->hw_irq_trigger = enable;
 491
 492         /* Enable/Disable the interrupt generator for data ready. */
 493         err = st_sensors_write_data_with_mask(indio_dev, drdy_addr,
 494                                               drdy_mask, (int)enable);
 495
 496 st_accel_set_dataready_irq_error:
 497         return err;
 498 }
 499 EXPORT_SYMBOL(st_sensors_set_dataready_irq);
 500
 501 int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
 502 {
 503         int err = -EINVAL, i;
 504         struct st_sensor_data *sdata = iio_priv(indio_dev);
 505
 506         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
 507                 if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
 508                                 (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
 509                         err = 0;
 510                         break;
 511                 }
 512         }
 513         if (err < 0)
 514                 goto st_sensors_match_scale_error;
 515
 516         err = st_sensors_set_fullscale(indio_dev,
 517                                 sdata->sensor_settings->fs.fs_avl[i].num);
 518
 519 st_sensors_match_scale_error:
 520         return err;
 521 }
 522 EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain);
 523
 524 static int st_sensors_read_axis_data(struct iio_dev *indio_dev,
 525                                      struct iio_chan_spec const *ch, int *data)
 526 {
 527         int err;
 528         u8 *outdata;
 529         struct st_sensor_data *sdata = iio_priv(indio_dev);
 530         unsigned int byte_for_channel;
 531
 532         byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits +
 533                                         ch->scan_type.shift, 8);
 534         outdata = kmalloc(byte_for_channel, GFP_DMA | GFP_KERNEL);
 535         if (!outdata)
 536                 return -ENOMEM;
 537
 538         err = regmap_bulk_read(sdata->regmap, ch->address,
 539                                outdata, byte_for_channel);
 540         if (err < 0)
 541                 goto st_sensors_free_memory;
 542
 543         if (byte_for_channel == 1)
 544                 *data = (s8)*outdata;
 545         else if (byte_for_channel == 2)
 546                 *data = (s16)get_unaligned_le16(outdata);
 547         else if (byte_for_channel == 3)
 548                 *data = (s32)st_sensors_get_unaligned_le24(outdata);
 549
 550 st_sensors_free_memory:
 551         kfree(outdata);
 552
 553         return err;
 554 }
 555
 556 int st_sensors_read_info_raw(struct iio_dev *indio_dev,
 557                                 struct iio_chan_spec const *ch, int *val)
 558 {
 559         int err;
 560         struct st_sensor_data *sdata = iio_priv(indio_dev);
 561
 562         mutex_lock(&indio_dev->mlock);
 563         if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
 564                 err = -EBUSY;
 565                 goto out;
 566         } else {
 567                 err = st_sensors_set_enable(indio_dev, true);
 568                 if (err < 0)
 569                         goto out;
 570
 571                 msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
 572                 err = st_sensors_read_axis_data(indio_dev, ch, val);
 573                 if (err < 0)
 574                         goto out;
 575
 576                 *val = *val >> ch->scan_type.shift;
 577
 578                 err = st_sensors_set_enable(indio_dev, false);
 579         }
 580 out:
 581         mutex_unlock(&indio_dev->mlock);
 582
 583         return err;
 584 }
 585 EXPORT_SYMBOL(st_sensors_read_info_raw);
 586
 587 /*
 588  * st_sensors_get_settings_index() - get index of the sensor settings for a
 589  *                                   specific device from list of settings
 590  * @name: device name buffer reference.
 591  * @list: sensor settings list.
 592  * @list_length: length of sensor settings list.
 593  *
 594  * Return: non negative number on success (valid index),
 595  *         negative error code otherwise.
 596  */
 597 int st_sensors_get_settings_index(const char *name,
 598                                   const struct st_sensor_settings *list,
 599                                   const int list_length)
 600 {
 601         int i, n;
 602
 603         for (i = 0; i < list_length; i++) {
 604                 for (n = 0; n < ST_SENSORS_MAX_4WAI; n++) {
 605                         if (strcmp(name, list[i].sensors_supported[n]) == 0)
 606                                 return i;
 607                 }
 608         }
 609
 610         return -ENODEV;
 611 }
 612 EXPORT_SYMBOL(st_sensors_get_settings_index);
 613
 614 /*
 615  * st_sensors_verify_id() - verify sensor ID (WhoAmI) is matching with the
 616  *                          expected value
 617  * @indio_dev: IIO device reference.
 618  *
 619  * Return: 0 on success (valid sensor ID), else a negative error code.
 620  */
 621 int st_sensors_verify_id(struct iio_dev *indio_dev)
 622 {
 623         struct st_sensor_data *sdata = iio_priv(indio_dev);
 624         int wai, err;
 625
 626         if (sdata->sensor_settings->wai_addr) {
 627                 err = regmap_read(sdata->regmap,
 628                                   sdata->sensor_settings->wai_addr, &wai);
 629                 if (err < 0) {
 630                         dev_err(&indio_dev->dev,
 631                                 "failed to read Who-Am-I register.\n");
 632                         return err;
 633                 }
 634
 635                 if (sdata->sensor_settings->wai != wai) {
 636                         dev_err(&indio_dev->dev,
 637                                 "%s: WhoAmI mismatch (0x%x).\n",
 638                                 indio_dev->name, wai);
 639                         return -EINVAL;
 640                 }
 641         }
 642
 643         return 0;
 644 }
 645 EXPORT_SYMBOL(st_sensors_verify_id);
 646
 647 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
 648                                 struct device_attribute *attr, char *buf)
 649 {
 650         int i, len = 0;
 651         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 652         struct st_sensor_data *sdata = iio_priv(indio_dev);
 653
 654         mutex_lock(&indio_dev->mlock);
 655         for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
 656                 if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
 657                         break;
 658
 659                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
 660                                 sdata->sensor_settings->odr.odr_avl[i].hz);
 661         }
 662         mutex_unlock(&indio_dev->mlock);
 663         buf[len - 1] = '\n';
 664
 665         return len;
 666 }
 667 EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail);
 668
 669 ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
 670                                 struct device_attribute *attr, char *buf)
 671 {
 672         int i, len = 0, q, r;
 673         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 674         struct st_sensor_data *sdata = iio_priv(indio_dev);
 675
 676         mutex_lock(&indio_dev->mlock);
 677         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
 678                 if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
 679                         break;
 680
 681                 q = sdata->sensor_settings->fs.fs_avl[i].gain / 1000000;
 682                 r = sdata->sensor_settings->fs.fs_avl[i].gain % 1000000;
 683
 684                 len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ", q, r);
 685         }
 686         mutex_unlock(&indio_dev->mlock);
 687         buf[len - 1] = '\n';
 688
 689         return len;
 690 }
 691 EXPORT_SYMBOL(st_sensors_sysfs_scale_avail);
 692
 693 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 694 MODULE_DESCRIPTION("STMicroelectronics ST-sensors core");
 695 MODULE_LICENSE("GPL v2");