1 /* IIO - useful set of util functionality
3 * Copyright (c) 2008 Jonathan Cameron
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
16 #include "iio_utils.h"
18 const char *iio_dir
= "/sys/bus/iio/devices/";
20 static char * const iio_direction
[] = {
26 * iioutils_break_up_name() - extract generic name from full channel name
27 * @full_name: the full channel name
28 * @generic_name: the output generic channel name
30 * Returns 0 on success, or a negative error code if string extraction failed.
32 int iioutils_break_up_name(const char *full_name
, char **generic_name
)
36 char *working
, *prefix
= "";
39 for (i
= 0; i
< ARRAY_SIZE(iio_direction
); i
++)
40 if (!strncmp(full_name
, iio_direction
[i
],
41 strlen(iio_direction
[i
]))) {
42 prefix
= iio_direction
[i
];
46 current
= strdup(full_name
+ strlen(prefix
) + 1);
50 working
= strtok(current
, "_\0");
68 ret
= asprintf(generic_name
, "%s_%s", prefix
, working
);
71 return (ret
== -1) ? -ENOMEM
: 0;
75 * iioutils_get_type() - find and process _type attribute data
76 * @is_signed: output whether channel is signed
77 * @bytes: output how many bytes the channel storage occupies
78 * @bits_used: output number of valid bits of data
79 * @shift: output amount of bits to shift right data before applying bit mask
80 * @mask: output a bit mask for the raw data
81 * @be: output if data in big endian
82 * @device_dir: the IIO device directory
83 * @name: the channel name
84 * @generic_name: the channel type name
86 * Returns a value >= 0 on success, otherwise a negative error code.
88 int iioutils_get_type(unsigned *is_signed
, unsigned *bytes
, unsigned *bits_used
,
89 unsigned *shift
, uint64_t *mask
, unsigned *be
,
90 const char *device_dir
, const char *name
,
91 const char *generic_name
)
96 char *scan_el_dir
, *builtname
, *builtname_generic
, *filename
= 0;
97 char signchar
, endianchar
;
99 const struct dirent
*ent
;
101 ret
= asprintf(&scan_el_dir
, FORMAT_SCAN_ELEMENTS_DIR
, device_dir
);
105 ret
= asprintf(&builtname
, FORMAT_TYPE_FILE
, name
);
108 goto error_free_scan_el_dir
;
110 ret
= asprintf(&builtname_generic
, FORMAT_TYPE_FILE
, generic_name
);
113 goto error_free_builtname
;
116 dp
= opendir(scan_el_dir
);
119 goto error_free_builtname_generic
;
123 while (ent
= readdir(dp
), ent
)
125 * Do we allow devices to override a generic name with
128 if ((strcmp(builtname
, ent
->d_name
) == 0) ||
129 (strcmp(builtname_generic
, ent
->d_name
) == 0)) {
130 ret
= asprintf(&filename
,
131 "%s/%s", scan_el_dir
, ent
->d_name
);
137 sysfsfp
= fopen(filename
, "r");
140 fprintf(stderr
, "failed to open %s\n",
142 goto error_free_filename
;
145 ret
= fscanf(sysfsfp
,
154 "failed to pass scan type description\n");
155 goto error_close_sysfsfp
;
156 } else if (ret
!= 5) {
159 "scan type description didn't match\n");
160 goto error_close_sysfsfp
;
163 *be
= (endianchar
== 'b');
165 if (*bits_used
== 64)
168 *mask
= (1ULL << *bits_used
) - 1;
170 *is_signed
= (signchar
== 's');
171 if (fclose(sysfsfp
)) {
173 fprintf(stderr
, "Failed to close %s\n",
175 goto error_free_filename
;
186 perror("iioutils_get_type(): Failed to close file");
193 if (closedir(dp
) == -1)
194 perror("iioutils_get_type(): Failed to close directory");
196 error_free_builtname_generic
:
197 free(builtname_generic
);
198 error_free_builtname
:
200 error_free_scan_el_dir
:
207 * iioutils_get_param_float() - read a float value from a channel parameter
208 * @output: output the float value
209 * @param_name: the parameter name to read
210 * @device_dir: the IIO device directory in sysfs
211 * @name: the channel name
212 * @generic_name: the channel type name
214 * Returns a value >= 0 on success, otherwise a negative error code.
216 int iioutils_get_param_float(float *output
, const char *param_name
,
217 const char *device_dir
, const char *name
,
218 const char *generic_name
)
223 char *builtname
, *builtname_generic
;
224 char *filename
= NULL
;
225 const struct dirent
*ent
;
227 ret
= asprintf(&builtname
, "%s_%s", name
, param_name
);
231 ret
= asprintf(&builtname_generic
,
232 "%s_%s", generic_name
, param_name
);
235 goto error_free_builtname
;
238 dp
= opendir(device_dir
);
241 goto error_free_builtname_generic
;
245 while (ent
= readdir(dp
), ent
)
246 if ((strcmp(builtname
, ent
->d_name
) == 0) ||
247 (strcmp(builtname_generic
, ent
->d_name
) == 0)) {
248 ret
= asprintf(&filename
,
249 "%s/%s", device_dir
, ent
->d_name
);
255 sysfsfp
= fopen(filename
, "r");
258 goto error_free_filename
;
262 if (fscanf(sysfsfp
, "%f", output
) != 1)
263 ret
= errno
? -errno
: -ENODATA
;
272 if (closedir(dp
) == -1)
273 perror("iioutils_get_param_float(): Failed to close directory");
275 error_free_builtname_generic
:
276 free(builtname_generic
);
277 error_free_builtname
:
284 * bsort_channel_array_by_index() - sort the array in index order
285 * @ci_array: the iio_channel_info array to be sorted
286 * @cnt: the amount of array elements
289 void bsort_channel_array_by_index(struct iio_channel_info
*ci_array
, int cnt
)
291 struct iio_channel_info temp
;
294 for (x
= 0; x
< cnt
; x
++)
295 for (y
= 0; y
< (cnt
- 1); y
++)
296 if (ci_array
[y
].index
> ci_array
[y
+ 1].index
) {
297 temp
= ci_array
[y
+ 1];
298 ci_array
[y
+ 1] = ci_array
[y
];
304 * build_channel_array() - function to figure out what channels are present
305 * @device_dir: the IIO device directory in sysfs
306 * @ci_array: output the resulting array of iio_channel_info
307 * @counter: output the amount of array elements
309 * Returns 0 on success, otherwise a negative error code.
311 int build_channel_array(const char *device_dir
,
312 struct iio_channel_info
**ci_array
, int *counter
)
317 struct iio_channel_info
*current
;
319 const struct dirent
*ent
;
324 ret
= asprintf(&scan_el_dir
, FORMAT_SCAN_ELEMENTS_DIR
, device_dir
);
328 dp
= opendir(scan_el_dir
);
331 goto error_free_name
;
334 while (ent
= readdir(dp
), ent
)
335 if (strcmp(ent
->d_name
+ strlen(ent
->d_name
) - strlen("_en"),
337 ret
= asprintf(&filename
,
338 "%s/%s", scan_el_dir
, ent
->d_name
);
341 goto error_close_dir
;
344 sysfsfp
= fopen(filename
, "r");
348 goto error_close_dir
;
352 if (fscanf(sysfsfp
, "%i", &ret
) != 1) {
353 ret
= errno
? -errno
: -ENODATA
;
355 perror("build_channel_array(): Failed to close file");
358 goto error_close_dir
;
363 if (fclose(sysfsfp
)) {
366 goto error_close_dir
;
372 *ci_array
= malloc(sizeof(**ci_array
) * (*counter
));
375 goto error_close_dir
;
379 while (ent
= readdir(dp
), ent
) {
380 if (strcmp(ent
->d_name
+ strlen(ent
->d_name
) - strlen("_en"),
382 int current_enabled
= 0;
384 current
= &(*ci_array
)[count
++];
385 ret
= asprintf(&filename
,
386 "%s/%s", scan_el_dir
, ent
->d_name
);
389 /* decrement count to avoid freeing name */
391 goto error_cleanup_array
;
394 sysfsfp
= fopen(filename
, "r");
399 goto error_cleanup_array
;
403 if (fscanf(sysfsfp
, "%i", ¤t_enabled
) != 1) {
404 ret
= errno
? -errno
: -ENODATA
;
407 goto error_cleanup_array
;
410 if (fclose(sysfsfp
)) {
414 goto error_cleanup_array
;
417 if (!current_enabled
) {
423 current
->scale
= 1.0;
425 current
->name
= strndup(ent
->d_name
,
426 strlen(ent
->d_name
) -
428 if (!current
->name
) {
432 goto error_cleanup_array
;
435 /* Get the generic and specific name elements */
436 ret
= iioutils_break_up_name(current
->name
,
437 ¤t
->generic_name
);
442 goto error_cleanup_array
;
445 ret
= asprintf(&filename
,
452 goto error_cleanup_array
;
455 sysfsfp
= fopen(filename
, "r");
458 fprintf(stderr
, "failed to open %s\n",
461 goto error_cleanup_array
;
465 if (fscanf(sysfsfp
, "%u", ¤t
->index
) != 1) {
466 ret
= errno
? -errno
: -ENODATA
;
468 perror("build_channel_array(): Failed to close file");
471 goto error_cleanup_array
;
474 if (fclose(sysfsfp
)) {
477 goto error_cleanup_array
;
482 ret
= iioutils_get_param_float(¤t
->scale
,
486 current
->generic_name
);
487 if ((ret
< 0) && (ret
!= -ENOENT
))
488 goto error_cleanup_array
;
490 ret
= iioutils_get_param_float(¤t
->offset
,
494 current
->generic_name
);
495 if ((ret
< 0) && (ret
!= -ENOENT
))
496 goto error_cleanup_array
;
498 ret
= iioutils_get_type(¤t
->is_signed
,
506 current
->generic_name
);
508 goto error_cleanup_array
;
512 if (closedir(dp
) == -1) {
514 goto error_cleanup_array
;
518 /* reorder so that the array is in index order */
519 bsort_channel_array_by_index(*ci_array
, *counter
);
524 for (i
= count
- 1; i
>= 0; i
--) {
525 free((*ci_array
)[i
].name
);
526 free((*ci_array
)[i
].generic_name
);
533 if (closedir(dp
) == -1)
534 perror("build_channel_array(): Failed to close dir");
542 static int calc_digits(int num
)
555 * find_type_by_name() - function to match top level types by name
556 * @name: top level type instance name
557 * @type: the type of top level instance being searched
559 * Returns the device number of a matched IIO device on success, otherwise a
560 * negative error code.
561 * Typical types this is used for are device and trigger.
563 int find_type_by_name(const char *name
, const char *type
)
565 const struct dirent
*ent
;
566 int number
, numstrlen
, ret
;
570 char thisname
[IIO_MAX_NAME_LENGTH
];
573 dp
= opendir(iio_dir
);
575 fprintf(stderr
, "No industrialio devices available\n");
579 while (ent
= readdir(dp
), ent
) {
580 if (strcmp(ent
->d_name
, ".") != 0 &&
581 strcmp(ent
->d_name
, "..") != 0 &&
582 strlen(ent
->d_name
) > strlen(type
) &&
583 strncmp(ent
->d_name
, type
, strlen(type
)) == 0) {
585 ret
= sscanf(ent
->d_name
+ strlen(type
), "%d", &number
);
589 "failed to read element number\n");
590 goto error_close_dir
;
591 } else if (ret
!= 1) {
594 "failed to match element number\n");
595 goto error_close_dir
;
598 numstrlen
= calc_digits(number
);
599 /* verify the next character is not a colon */
600 if (strncmp(ent
->d_name
+ strlen(type
) + numstrlen
,
602 filename
= malloc(strlen(iio_dir
) + strlen(type
)
606 goto error_close_dir
;
609 ret
= sprintf(filename
, "%s%s%d/name", iio_dir
,
613 goto error_close_dir
;
616 namefp
= fopen(filename
, "r");
624 if (fscanf(namefp
, "%s", thisname
) != 1) {
625 ret
= errno
? -errno
: -ENODATA
;
626 goto error_close_dir
;
629 if (fclose(namefp
)) {
631 goto error_close_dir
;
634 if (strcmp(name
, thisname
) == 0) {
635 if (closedir(dp
) == -1)
643 if (closedir(dp
) == -1)
649 if (closedir(dp
) == -1)
650 perror("find_type_by_name(): Failed to close directory");
655 static int _write_sysfs_int(const char *filename
, const char *basedir
, int val
,
661 char *temp
= malloc(strlen(basedir
) + strlen(filename
) + 2);
666 ret
= sprintf(temp
, "%s/%s", basedir
, filename
);
670 sysfsfp
= fopen(temp
, "w");
673 fprintf(stderr
, "failed to open %s\n", temp
);
677 ret
= fprintf(sysfsfp
, "%d", val
);
680 perror("_write_sysfs_int(): Failed to close dir");
685 if (fclose(sysfsfp
)) {
691 sysfsfp
= fopen(temp
, "r");
694 fprintf(stderr
, "failed to open %s\n", temp
);
698 if (fscanf(sysfsfp
, "%d", &test
) != 1) {
699 ret
= errno
? -errno
: -ENODATA
;
701 perror("_write_sysfs_int(): Failed to close dir");
706 if (fclose(sysfsfp
)) {
713 "Possible failure in int write %d to %s/%s\n",
714 val
, basedir
, filename
);
725 * write_sysfs_int() - write an integer value to a sysfs file
726 * @filename: name of the file to write to
727 * @basedir: the sysfs directory in which the file is to be found
728 * @val: integer value to write to file
730 * Returns a value >= 0 on success, otherwise a negative error code.
732 int write_sysfs_int(const char *filename
, const char *basedir
, int val
)
734 return _write_sysfs_int(filename
, basedir
, val
, 0);
738 * write_sysfs_int_and_verify() - write an integer value to a sysfs file
740 * @filename: name of the file to write to
741 * @basedir: the sysfs directory in which the file is to be found
742 * @val: integer value to write to file
744 * Returns a value >= 0 on success, otherwise a negative error code.
746 int write_sysfs_int_and_verify(const char *filename
, const char *basedir
,
749 return _write_sysfs_int(filename
, basedir
, val
, 1);
752 static int _write_sysfs_string(const char *filename
, const char *basedir
,
753 const char *val
, int verify
)
757 char *temp
= malloc(strlen(basedir
) + strlen(filename
) + 2);
760 fprintf(stderr
, "Memory allocation failed\n");
764 ret
= sprintf(temp
, "%s/%s", basedir
, filename
);
768 sysfsfp
= fopen(temp
, "w");
771 fprintf(stderr
, "Could not open %s\n", temp
);
775 ret
= fprintf(sysfsfp
, "%s", val
);
778 perror("_write_sysfs_string(): Failed to close dir");
783 if (fclose(sysfsfp
)) {
789 sysfsfp
= fopen(temp
, "r");
792 fprintf(stderr
, "Could not open file to verify\n");
796 if (fscanf(sysfsfp
, "%s", temp
) != 1) {
797 ret
= errno
? -errno
: -ENODATA
;
799 perror("_write_sysfs_string(): Failed to close dir");
804 if (fclose(sysfsfp
)) {
809 if (strcmp(temp
, val
) != 0) {
811 "Possible failure in string write of %s "
812 "Should be %s written to %s/%s\n", temp
, val
,
825 * write_sysfs_string_and_verify() - string write, readback and verify
826 * @filename: name of file to write to
827 * @basedir: the sysfs directory in which the file is to be found
828 * @val: the string to write
830 * Returns a value >= 0 on success, otherwise a negative error code.
832 int write_sysfs_string_and_verify(const char *filename
, const char *basedir
,
835 return _write_sysfs_string(filename
, basedir
, val
, 1);
839 * write_sysfs_string() - write string to a sysfs file
840 * @filename: name of file to write to
841 * @basedir: the sysfs directory in which the file is to be found
842 * @val: the string to write
844 * Returns a value >= 0 on success, otherwise a negative error code.
846 int write_sysfs_string(const char *filename
, const char *basedir
,
849 return _write_sysfs_string(filename
, basedir
, val
, 0);
853 * read_sysfs_posint() - read an integer value from file
854 * @filename: name of file to read from
855 * @basedir: the sysfs directory in which the file is to be found
857 * Returns the read integer value >= 0 on success, otherwise a negative error
860 int read_sysfs_posint(const char *filename
, const char *basedir
)
864 char *temp
= malloc(strlen(basedir
) + strlen(filename
) + 2);
867 fprintf(stderr
, "Memory allocation failed");
871 ret
= sprintf(temp
, "%s/%s", basedir
, filename
);
875 sysfsfp
= fopen(temp
, "r");
882 if (fscanf(sysfsfp
, "%d\n", &ret
) != 1) {
883 ret
= errno
? -errno
: -ENODATA
;
885 perror("read_sysfs_posint(): Failed to close dir");
900 * read_sysfs_float() - read a float value from file
901 * @filename: name of file to read from
902 * @basedir: the sysfs directory in which the file is to be found
903 * @val: output the read float value
905 * Returns a value >= 0 on success, otherwise a negative error code.
907 int read_sysfs_float(const char *filename
, const char *basedir
, float *val
)
911 char *temp
= malloc(strlen(basedir
) + strlen(filename
) + 2);
914 fprintf(stderr
, "Memory allocation failed");
918 ret
= sprintf(temp
, "%s/%s", basedir
, filename
);
922 sysfsfp
= fopen(temp
, "r");
929 if (fscanf(sysfsfp
, "%f\n", val
) != 1) {
930 ret
= errno
? -errno
: -ENODATA
;
932 perror("read_sysfs_float(): Failed to close dir");
947 * read_sysfs_string() - read a string from file
948 * @filename: name of file to read from
949 * @basedir: the sysfs directory in which the file is to be found
950 * @str: output the read string
952 * Returns a value >= 0 on success, otherwise a negative error code.
954 int read_sysfs_string(const char *filename
, const char *basedir
, char *str
)
958 char *temp
= malloc(strlen(basedir
) + strlen(filename
) + 2);
961 fprintf(stderr
, "Memory allocation failed");
965 ret
= sprintf(temp
, "%s/%s", basedir
, filename
);
969 sysfsfp
= fopen(temp
, "r");
976 if (fscanf(sysfsfp
, "%s\n", str
) != 1) {
977 ret
= errno
? -errno
: -ENODATA
;
979 perror("read_sysfs_string(): Failed to close dir");