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