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