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.addr) 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"); 696