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