1
2
3
4
5
6
7
8
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
24static 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
29int 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
43st_sensors_write_data_with_mask_error:
44 return err;
45}
46
47int 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}
67EXPORT_SYMBOL(st_sensors_debugfs_reg_access);
68
69static 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
86st_sensors_match_odr_error:
87 return ret;
88}
89
90int 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
124st_sensors_match_odr_error:
125 return err;
126}
127EXPORT_SYMBOL(st_sensors_set_odr);
128
129static 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
145st_sensors_match_odr_error:
146 return ret;
147}
148
149static 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
172st_accel_set_fullscale_error:
173 dev_err(&indio_dev->dev, "failed to set new fullscale.\n");
174 return err;
175}
176
177int 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
219set_enable_error:
220 return err;
221}
222EXPORT_SYMBOL(st_sensors_set_enable);
223
224int 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}
236EXPORT_SYMBOL(st_sensors_set_axis_enable);
237
238int 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
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
271st_sensors_disable_vdd:
272 regulator_disable(pdata->vdd);
273 return err;
274}
275EXPORT_SYMBOL(st_sensors_power_enable);
276
277void 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}
284EXPORT_SYMBOL(st_sensors_power_disable);
285
286static 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
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
337static 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
360
361
362
363
364
365
366
367
368
369
370
371
372void 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
383 strncpy(name, of_id->data, len);
384 name[len - 1] = '\0';
385}
386EXPORT_SYMBOL(st_sensors_of_name_probe);
387#else
388static 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
395int 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
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
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
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
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}
476EXPORT_SYMBOL(st_sensors_init_sensor);
477
478int 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
488
489
490
491
492 if (sdata->sensor_settings->drdy_irq.stat_drdy.addr)
493 sdata->hw_irq_trigger = enable;
494 return 0;
495 }
496
497
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
516 sdata->hw_irq_trigger = enable;
517
518
519 err = st_sensors_write_data_with_mask(indio_dev, drdy_addr,
520 drdy_mask, (int)enable);
521
522st_accel_set_dataready_irq_error:
523 return err;
524}
525EXPORT_SYMBOL(st_sensors_set_dataready_irq);
526
527int 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
545st_sensors_match_scale_error:
546 return err;
547}
548EXPORT_SYMBOL(st_sensors_set_fullscale_by_gain);
549
550static 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
577st_sensors_free_memory:
578 kfree(outdata);
579
580 return err;
581}
582
583int 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 }
607out:
608 mutex_unlock(&indio_dev->mlock);
609
610 return err;
611}
612EXPORT_SYMBOL(st_sensors_read_info_raw);
613
614static 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
639int 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}
689EXPORT_SYMBOL(st_sensors_check_device_support);
690
691ssize_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}
711EXPORT_SYMBOL(st_sensors_sysfs_sampling_frequency_avail);
712
713ssize_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}
735EXPORT_SYMBOL(st_sensors_sysfs_scale_avail);
736
737MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
738MODULE_DESCRIPTION("STMicroelectronics ST-sensors core");
739MODULE_LICENSE("GPL v2");
740
