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