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
st_sensors_write_data_with_mask(struct iio_dev * indio_dev,u8 reg_addr,u8 mask,u8 data)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
st_sensors_debugfs_reg_access(struct iio_dev * indio_dev,unsigned reg,unsigned writeval,unsigned * readval)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
st_sensors_match_odr(struct st_sensor_settings * sensor_settings,unsigned int odr,struct st_sensor_odr_avl * odr_out)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
st_sensors_set_odr(struct iio_dev * indio_dev,unsigned int odr)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
st_sensors_match_fs(struct st_sensor_settings * sensor_settings,unsigned int fs,int * index_fs_avl)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
st_sensors_set_fullscale(struct iio_dev * indio_dev,unsigned int fs)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
st_sensors_set_enable(struct iio_dev * indio_dev,bool enable)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
st_sensors_set_axis_enable(struct iio_dev * indio_dev,u8 axis_enable)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
st_sensors_power_enable(struct iio_dev * indio_dev)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
st_sensors_power_disable(struct iio_dev * indio_dev)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
st_sensors_set_drdy_int_pin(struct iio_dev * indio_dev,struct st_sensors_platform_data * pdata)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
st_sensors_dev_probe(struct device * dev,struct st_sensors_platform_data * defdata)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 */
st_sensors_dev_name_probe(struct device * dev,char * name,int len)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
st_sensors_init_sensor(struct iio_dev * indio_dev,struct st_sensors_platform_data * pdata)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
st_sensors_set_dataready_irq(struct iio_dev * indio_dev,bool enable)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
st_sensors_set_fullscale_by_gain(struct iio_dev * indio_dev,int scale)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
st_sensors_read_axis_data(struct iio_dev * indio_dev,struct iio_chan_spec const * ch,int * data)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
st_sensors_read_info_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * ch,int * val)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 */
st_sensors_get_settings_index(const char * name,const struct st_sensor_settings * list,const int list_length)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 */
st_sensors_verify_id(struct iio_dev * indio_dev)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
st_sensors_sysfs_sampling_frequency_avail(struct device * dev,struct device_attribute * attr,char * buf)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
st_sensors_sysfs_scale_avail(struct device * dev,struct device_attribute * attr,char * buf)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");
701