1 // SPDX-License-Identifier: GPL-2.0-only
2 /* IIO - useful set of util functionality
3  *
4  * Copyright (c) 2008 Jonathan Cameron
5  */
6 #include <string.h>
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <stdint.h>
10 #include <dirent.h>
11 #include <errno.h>
12 #include <ctype.h>
13 #include "iio_utils.h"
14 
15 const char *iio_dir = "/sys/bus/iio/devices/";
16 
17 static char * const iio_direction[] = {
18 	"in",
19 	"out",
20 };
21 
22 /**
23  * iioutils_break_up_name() - extract generic name from full channel name
24  * @full_name: the full channel name
25  * @generic_name: the output generic channel name
26  *
27  * Returns 0 on success, or a negative error code if string extraction failed.
28  **/
iioutils_break_up_name(const char * full_name,char ** generic_name)29 int iioutils_break_up_name(const char *full_name, char **generic_name)
30 {
31 	char *current;
32 	char *w, *r;
33 	char *working, *prefix = "";
34 	int i, ret;
35 
36 	for (i = 0; i < ARRAY_SIZE(iio_direction); i++)
37 		if (!strncmp(full_name, iio_direction[i],
38 			     strlen(iio_direction[i]))) {
39 			prefix = iio_direction[i];
40 			break;
41 		}
42 
43 	current = strdup(full_name + strlen(prefix) + 1);
44 	if (!current)
45 		return -ENOMEM;
46 
47 	working = strtok(current, "_\0");
48 	if (!working) {
49 		free(current);
50 		return -EINVAL;
51 	}
52 
53 	w = working;
54 	r = working;
55 
56 	while (*r != '\0') {
57 		if (!isdigit(*r)) {
58 			*w = *r;
59 			w++;
60 		}
61 
62 		r++;
63 	}
64 	*w = '\0';
65 	ret = asprintf(generic_name, "%s_%s", prefix, working);
66 	free(current);
67 
68 	return (ret == -1) ? -ENOMEM : 0;
69 }
70 
71 /**
72  * iioutils_get_type() - find and process _type attribute data
73  * @is_signed: output whether channel is signed
74  * @bytes: output how many bytes the channel storage occupies
75  * @bits_used: output number of valid bits of data
76  * @shift: output amount of bits to shift right data before applying bit mask
77  * @mask: output a bit mask for the raw data
78  * @be: output if data in big endian
79  * @device_dir: the IIO device directory
80  * @buffer_idx: the IIO buffer index
81  * @name: the channel name
82  * @generic_name: the channel type name
83  *
84  * Returns a value >= 0 on success, otherwise a negative error code.
85  **/
iioutils_get_type(unsigned int * is_signed,unsigned int * bytes,unsigned int * bits_used,unsigned int * shift,uint64_t * mask,unsigned int * be,const char * device_dir,int buffer_idx,const char * name,const char * generic_name)86 static int iioutils_get_type(unsigned int *is_signed, unsigned int *bytes,
87 			     unsigned int *bits_used, unsigned int *shift,
88 			     uint64_t *mask, unsigned int *be,
89 			     const char *device_dir, int buffer_idx,
90 			     const char *name, const char *generic_name)
91 {
92 	FILE *sysfsfp;
93 	int ret;
94 	DIR *dp;
95 	char *scan_el_dir, *builtname, *builtname_generic, *filename = 0;
96 	char signchar, endianchar;
97 	unsigned padint;
98 	const struct dirent *ent;
99 
100 	ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir, buffer_idx);
101 	if (ret < 0)
102 		return -ENOMEM;
103 
104 	ret = asprintf(&builtname, FORMAT_TYPE_FILE, name);
105 	if (ret < 0) {
106 		ret = -ENOMEM;
107 		goto error_free_scan_el_dir;
108 	}
109 	ret = asprintf(&builtname_generic, FORMAT_TYPE_FILE, generic_name);
110 	if (ret < 0) {
111 		ret = -ENOMEM;
112 		goto error_free_builtname;
113 	}
114 
115 	dp = opendir(scan_el_dir);
116 	if (!dp) {
117 		ret = -errno;
118 		goto error_free_builtname_generic;
119 	}
120 
121 	ret = -ENOENT;
122 	while (ent = readdir(dp), ent)
123 		if ((strcmp(builtname, ent->d_name) == 0) ||
124 		    (strcmp(builtname_generic, ent->d_name) == 0)) {
125 			ret = asprintf(&filename,
126 				       "%s/%s", scan_el_dir, ent->d_name);
127 			if (ret < 0) {
128 				ret = -ENOMEM;
129 				goto error_closedir;
130 			}
131 
132 			sysfsfp = fopen(filename, "r");
133 			if (!sysfsfp) {
134 				ret = -errno;
135 				fprintf(stderr, "failed to open %s\n",
136 					filename);
137 				goto error_free_filename;
138 			}
139 
140 			ret = fscanf(sysfsfp,
141 				     "%ce:%c%u/%u>>%u",
142 				     &endianchar,
143 				     &signchar,
144 				     bits_used,
145 				     &padint, shift);
146 			if (ret < 0) {
147 				ret = -errno;
148 				fprintf(stderr,
149 					"failed to pass scan type description\n");
150 				goto error_close_sysfsfp;
151 			} else if (ret != 5) {
152 				ret = -EIO;
153 				fprintf(stderr,
154 					"scan type description didn't match\n");
155 				goto error_close_sysfsfp;
156 			}
157 
158 			*be = (endianchar == 'b');
159 			*bytes = padint / 8;
160 			if (*bits_used == 64)
161 				*mask = ~(0ULL);
162 			else
163 				*mask = (1ULL << *bits_used) - 1ULL;
164 
165 			*is_signed = (signchar == 's');
166 			if (fclose(sysfsfp)) {
167 				ret = -errno;
168 				fprintf(stderr, "Failed to close %s\n",
169 					filename);
170 				goto error_free_filename;
171 			}
172 
173 			sysfsfp = 0;
174 			free(filename);
175 			filename = 0;
176 
177 			/*
178 			 * Avoid having a more generic entry overwriting
179 			 * the settings.
180 			 */
181 			if (strcmp(builtname, ent->d_name) == 0)
182 				break;
183 		}
184 
185 error_close_sysfsfp:
186 	if (sysfsfp)
187 		if (fclose(sysfsfp))
188 			perror("iioutils_get_type(): Failed to close file");
189 
190 error_free_filename:
191 	if (filename)
192 		free(filename);
193 
194 error_closedir:
195 	if (closedir(dp) == -1)
196 		perror("iioutils_get_type(): Failed to close directory");
197 
198 error_free_builtname_generic:
199 	free(builtname_generic);
200 error_free_builtname:
201 	free(builtname);
202 error_free_scan_el_dir:
203 	free(scan_el_dir);
204 
205 	return ret;
206 }
207 
208 /**
209  * iioutils_get_param_float() - read a float value from a channel parameter
210  * @output: output the float value
211  * @param_name: the parameter name to read
212  * @device_dir: the IIO device directory in sysfs
213  * @name: the channel name
214  * @generic_name: the channel type name
215  *
216  * Returns a value >= 0 on success, otherwise a negative error code.
217  **/
iioutils_get_param_float(float * output,const char * param_name,const char * device_dir,const char * name,const char * generic_name)218 int iioutils_get_param_float(float *output, const char *param_name,
219 			     const char *device_dir, const char *name,
220 			     const char *generic_name)
221 {
222 	FILE *sysfsfp;
223 	int ret;
224 	DIR *dp;
225 	char *builtname, *builtname_generic;
226 	char *filename = NULL;
227 	const struct dirent *ent;
228 
229 	ret = asprintf(&builtname, "%s_%s", name, param_name);
230 	if (ret < 0)
231 		return -ENOMEM;
232 
233 	ret = asprintf(&builtname_generic,
234 		       "%s_%s", generic_name, param_name);
235 	if (ret < 0) {
236 		ret = -ENOMEM;
237 		goto error_free_builtname;
238 	}
239 
240 	dp = opendir(device_dir);
241 	if (!dp) {
242 		ret = -errno;
243 		goto error_free_builtname_generic;
244 	}
245 
246 	ret = -ENOENT;
247 	while (ent = readdir(dp), ent)
248 		if ((strcmp(builtname, ent->d_name) == 0) ||
249 		    (strcmp(builtname_generic, ent->d_name) == 0)) {
250 			ret = asprintf(&filename,
251 				       "%s/%s", device_dir, ent->d_name);
252 			if (ret < 0) {
253 				ret = -ENOMEM;
254 				goto error_closedir;
255 			}
256 
257 			sysfsfp = fopen(filename, "r");
258 			if (!sysfsfp) {
259 				ret = -errno;
260 				goto error_free_filename;
261 			}
262 
263 			errno = 0;
264 			if (fscanf(sysfsfp, "%f", output) != 1)
265 				ret = errno ? -errno : -ENODATA;
266 
267 			break;
268 		}
269 error_free_filename:
270 	if (filename)
271 		free(filename);
272 
273 error_closedir:
274 	if (closedir(dp) == -1)
275 		perror("iioutils_get_param_float(): Failed to close directory");
276 
277 error_free_builtname_generic:
278 	free(builtname_generic);
279 error_free_builtname:
280 	free(builtname);
281 
282 	return ret;
283 }
284 
285 /**
286  * bsort_channel_array_by_index() - sort the array in index order
287  * @ci_array: the iio_channel_info array to be sorted
288  * @cnt: the amount of array elements
289  **/
290 
bsort_channel_array_by_index(struct iio_channel_info * ci_array,int cnt)291 void bsort_channel_array_by_index(struct iio_channel_info *ci_array, int cnt)
292 {
293 	struct iio_channel_info temp;
294 	int x, y;
295 
296 	for (x = 0; x < cnt; x++)
297 		for (y = 0; y < (cnt - 1); y++)
298 			if (ci_array[y].index > ci_array[y + 1].index) {
299 				temp = ci_array[y + 1];
300 				ci_array[y + 1] = ci_array[y];
301 				ci_array[y] = temp;
302 			}
303 }
304 
305 /**
306  * build_channel_array() - function to figure out what channels are present
307  * @device_dir: the IIO device directory in sysfs
308  * @buffer_idx: the IIO buffer for this channel array
309  * @ci_array: output the resulting array of iio_channel_info
310  * @counter: output the amount of array elements
311  *
312  * Returns 0 on success, otherwise a negative error code.
313  **/
build_channel_array(const char * device_dir,int buffer_idx,struct iio_channel_info ** ci_array,int * counter)314 int build_channel_array(const char *device_dir, int buffer_idx,
315 			struct iio_channel_info **ci_array, int *counter)
316 {
317 	DIR *dp;
318 	FILE *sysfsfp;
319 	int count = 0, i;
320 	struct iio_channel_info *current;
321 	int ret;
322 	const struct dirent *ent;
323 	char *scan_el_dir;
324 	char *filename;
325 
326 	*counter = 0;
327 	ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir, buffer_idx);
328 	if (ret < 0)
329 		return -ENOMEM;
330 
331 	dp = opendir(scan_el_dir);
332 	if (!dp) {
333 		ret = -errno;
334 		goto error_free_name;
335 	}
336 
337 	while (ent = readdir(dp), ent)
338 		if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"),
339 			   "_en") == 0) {
340 			ret = asprintf(&filename,
341 				       "%s/%s", scan_el_dir, ent->d_name);
342 			if (ret < 0) {
343 				ret = -ENOMEM;
344 				goto error_close_dir;
345 			}
346 
347 			sysfsfp = fopen(filename, "r");
348 			if (!sysfsfp) {
349 				ret = -errno;
350 				free(filename);
351 				goto error_close_dir;
352 			}
353 
354 			errno = 0;
355 			if (fscanf(sysfsfp, "%i", &ret) != 1) {
356 				ret = errno ? -errno : -ENODATA;
357 				if (fclose(sysfsfp))
358 					perror("build_channel_array(): Failed to close file");
359 
360 				free(filename);
361 				goto error_close_dir;
362 			}
363 			if (ret == 1)
364 				(*counter)++;
365 
366 			if (fclose(sysfsfp)) {
367 				ret = -errno;
368 				free(filename);
369 				goto error_close_dir;
370 			}
371 
372 			free(filename);
373 		}
374 
375 	*ci_array = malloc(sizeof(**ci_array) * (*counter));
376 	if (!*ci_array) {
377 		ret = -ENOMEM;
378 		goto error_close_dir;
379 	}
380 
381 	seekdir(dp, 0);
382 	while (ent = readdir(dp), ent) {
383 		if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"),
384 			   "_en") == 0) {
385 			int current_enabled = 0;
386 
387 			current = &(*ci_array)[count++];
388 			ret = asprintf(&filename,
389 				       "%s/%s", scan_el_dir, ent->d_name);
390 			if (ret < 0) {
391 				ret = -ENOMEM;
392 				/* decrement count to avoid freeing name */
393 				count--;
394 				goto error_cleanup_array;
395 			}
396 
397 			sysfsfp = fopen(filename, "r");
398 			if (!sysfsfp) {
399 				ret = -errno;
400 				free(filename);
401 				count--;
402 				goto error_cleanup_array;
403 			}
404 
405 			errno = 0;
406 			if (fscanf(sysfsfp, "%i", &current_enabled) != 1) {
407 				ret = errno ? -errno : -ENODATA;
408 				free(filename);
409 				count--;
410 				goto error_cleanup_array;
411 			}
412 
413 			if (fclose(sysfsfp)) {
414 				ret = -errno;
415 				free(filename);
416 				count--;
417 				goto error_cleanup_array;
418 			}
419 
420 			if (!current_enabled) {
421 				free(filename);
422 				count--;
423 				continue;
424 			}
425 
426 			current->scale = 1.0;
427 			current->offset = 0;
428 			current->name = strndup(ent->d_name,
429 						strlen(ent->d_name) -
430 						strlen("_en"));
431 			if (!current->name) {
432 				free(filename);
433 				ret = -ENOMEM;
434 				count--;
435 				goto error_cleanup_array;
436 			}
437 
438 			/* Get the generic and specific name elements */
439 			ret = iioutils_break_up_name(current->name,
440 						     &current->generic_name);
441 			if (ret) {
442 				free(filename);
443 				free(current->name);
444 				count--;
445 				goto error_cleanup_array;
446 			}
447 
448 			ret = asprintf(&filename,
449 				       "%s/%s_index",
450 				       scan_el_dir,
451 				       current->name);
452 			if (ret < 0) {
453 				free(filename);
454 				ret = -ENOMEM;
455 				goto error_cleanup_array;
456 			}
457 
458 			sysfsfp = fopen(filename, "r");
459 			if (!sysfsfp) {
460 				ret = -errno;
461 				fprintf(stderr, "failed to open %s\n",
462 					filename);
463 				free(filename);
464 				goto error_cleanup_array;
465 			}
466 
467 			errno = 0;
468 			if (fscanf(sysfsfp, "%u", &current->index) != 1) {
469 				ret = errno ? -errno : -ENODATA;
470 				if (fclose(sysfsfp))
471 					perror("build_channel_array(): Failed to close file");
472 
473 				free(filename);
474 				goto error_cleanup_array;
475 			}
476 
477 			if (fclose(sysfsfp)) {
478 				ret = -errno;
479 				free(filename);
480 				goto error_cleanup_array;
481 			}
482 
483 			free(filename);
484 			/* Find the scale */
485 			ret = iioutils_get_param_float(&current->scale,
486 						       "scale",
487 						       device_dir,
488 						       current->name,
489 						       current->generic_name);
490 			if ((ret < 0) && (ret != -ENOENT))
491 				goto error_cleanup_array;
492 
493 			ret = iioutils_get_param_float(&current->offset,
494 						       "offset",
495 						       device_dir,
496 						       current->name,
497 						       current->generic_name);
498 			if ((ret < 0) && (ret != -ENOENT))
499 				goto error_cleanup_array;
500 
501 			ret = iioutils_get_type(&current->is_signed,
502 						&current->bytes,
503 						&current->bits_used,
504 						&current->shift,
505 						&current->mask,
506 						&current->be,
507 						device_dir,
508 						buffer_idx,
509 						current->name,
510 						current->generic_name);
511 			if (ret < 0)
512 				goto error_cleanup_array;
513 		}
514 	}
515 
516 	if (closedir(dp) == -1) {
517 		ret = -errno;
518 		goto error_cleanup_array;
519 	}
520 
521 	free(scan_el_dir);
522 	/* reorder so that the array is in index order */
523 	bsort_channel_array_by_index(*ci_array, *counter);
524 
525 	return 0;
526 
527 error_cleanup_array:
528 	for (i = count - 1;  i >= 0; i--) {
529 		free((*ci_array)[i].name);
530 		free((*ci_array)[i].generic_name);
531 	}
532 	free(*ci_array);
533 	*ci_array = NULL;
534 	*counter = 0;
535 error_close_dir:
536 	if (dp)
537 		if (closedir(dp) == -1)
538 			perror("build_channel_array(): Failed to close dir");
539 
540 error_free_name:
541 	free(scan_el_dir);
542 
543 	return ret;
544 }
545 
calc_digits(int num)546 static int calc_digits(int num)
547 {
548 	int count = 0;
549 
550 	while (num != 0) {
551 		num /= 10;
552 		count++;
553 	}
554 
555 	return count;
556 }
557 
558 /**
559  * find_type_by_name() - function to match top level types by name
560  * @name: top level type instance name
561  * @type: the type of top level instance being searched
562  *
563  * Returns the device number of a matched IIO device on success, otherwise a
564  * negative error code.
565  * Typical types this is used for are device and trigger.
566  **/
find_type_by_name(const char * name,const char * type)567 int find_type_by_name(const char *name, const char *type)
568 {
569 	const struct dirent *ent;
570 	int number, numstrlen, ret;
571 
572 	FILE *namefp;
573 	DIR *dp;
574 	char thisname[IIO_MAX_NAME_LENGTH];
575 	char *filename;
576 
577 	dp = opendir(iio_dir);
578 	if (!dp) {
579 		fprintf(stderr, "No industrialio devices available\n");
580 		return -ENODEV;
581 	}
582 
583 	while (ent = readdir(dp), ent) {
584 		if (strcmp(ent->d_name, ".") != 0 &&
585 		    strcmp(ent->d_name, "..") != 0 &&
586 		    strlen(ent->d_name) > strlen(type) &&
587 		    strncmp(ent->d_name, type, strlen(type)) == 0) {
588 			errno = 0;
589 			ret = sscanf(ent->d_name + strlen(type), "%d", &number);
590 			if (ret < 0) {
591 				ret = -errno;
592 				fprintf(stderr,
593 					"failed to read element number\n");
594 				goto error_close_dir;
595 			} else if (ret != 1) {
596 				ret = -EIO;
597 				fprintf(stderr,
598 					"failed to match element number\n");
599 				goto error_close_dir;
600 			}
601 
602 			numstrlen = calc_digits(number);
603 			/* verify the next character is not a colon */
604 			if (strncmp(ent->d_name + strlen(type) + numstrlen,
605 			    ":", 1) != 0) {
606 				filename = malloc(strlen(iio_dir) + strlen(type)
607 						  + numstrlen + 6);
608 				if (!filename) {
609 					ret = -ENOMEM;
610 					goto error_close_dir;
611 				}
612 
613 				ret = sprintf(filename, "%s%s%d/name", iio_dir,
614 					      type, number);
615 				if (ret < 0) {
616 					free(filename);
617 					goto error_close_dir;
618 				}
619 
620 				namefp = fopen(filename, "r");
621 				if (!namefp) {
622 					free(filename);
623 					continue;
624 				}
625 
626 				free(filename);
627 				errno = 0;
628 				if (fscanf(namefp, "%s", thisname) != 1) {
629 					ret = errno ? -errno : -ENODATA;
630 					goto error_close_dir;
631 				}
632 
633 				if (fclose(namefp)) {
634 					ret = -errno;
635 					goto error_close_dir;
636 				}
637 
638 				if (strcmp(name, thisname) == 0) {
639 					if (closedir(dp) == -1)
640 						return -errno;
641 
642 					return number;
643 				}
644 			}
645 		}
646 	}
647 	if (closedir(dp) == -1)
648 		return -errno;
649 
650 	return -ENODEV;
651 
652 error_close_dir:
653 	if (closedir(dp) == -1)
654 		perror("find_type_by_name(): Failed to close directory");
655 
656 	return ret;
657 }
658 
_write_sysfs_int(const char * filename,const char * basedir,int val,int verify)659 static int _write_sysfs_int(const char *filename, const char *basedir, int val,
660 			    int verify)
661 {
662 	int ret = 0;
663 	FILE *sysfsfp;
664 	int test;
665 	char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
666 
667 	if (!temp)
668 		return -ENOMEM;
669 
670 	ret = sprintf(temp, "%s/%s", basedir, filename);
671 	if (ret < 0)
672 		goto error_free;
673 
674 	sysfsfp = fopen(temp, "w");
675 	if (!sysfsfp) {
676 		ret = -errno;
677 		fprintf(stderr, "failed to open %s\n", temp);
678 		goto error_free;
679 	}
680 
681 	ret = fprintf(sysfsfp, "%d", val);
682 	if (ret < 0) {
683 		if (fclose(sysfsfp))
684 			perror("_write_sysfs_int(): Failed to close dir");
685 
686 		goto error_free;
687 	}
688 
689 	if (fclose(sysfsfp)) {
690 		ret = -errno;
691 		goto error_free;
692 	}
693 
694 	if (verify) {
695 		sysfsfp = fopen(temp, "r");
696 		if (!sysfsfp) {
697 			ret = -errno;
698 			fprintf(stderr, "failed to open %s\n", temp);
699 			goto error_free;
700 		}
701 
702 		if (fscanf(sysfsfp, "%d", &test) != 1) {
703 			ret = errno ? -errno : -ENODATA;
704 			if (fclose(sysfsfp))
705 				perror("_write_sysfs_int(): Failed to close dir");
706 
707 			goto error_free;
708 		}
709 
710 		if (fclose(sysfsfp)) {
711 			ret = -errno;
712 			goto error_free;
713 		}
714 
715 		if (test != val) {
716 			fprintf(stderr,
717 				"Possible failure in int write %d to %s/%s\n",
718 				val, basedir, filename);
719 			ret = -1;
720 		}
721 	}
722 
723 error_free:
724 	free(temp);
725 	return ret;
726 }
727 
728 /**
729  * write_sysfs_int() - write an integer value to a sysfs file
730  * @filename: name of the file to write to
731  * @basedir: the sysfs directory in which the file is to be found
732  * @val: integer value to write to file
733  *
734  * Returns a value >= 0 on success, otherwise a negative error code.
735  **/
write_sysfs_int(const char * filename,const char * basedir,int val)736 int write_sysfs_int(const char *filename, const char *basedir, int val)
737 {
738 	return _write_sysfs_int(filename, basedir, val, 0);
739 }
740 
741 /**
742  * write_sysfs_int_and_verify() - write an integer value to a sysfs file
743  *				  and verify
744  * @filename: name of the file to write to
745  * @basedir: the sysfs directory in which the file is to be found
746  * @val: integer value to write to file
747  *
748  * Returns a value >= 0 on success, otherwise a negative error code.
749  **/
write_sysfs_int_and_verify(const char * filename,const char * basedir,int val)750 int write_sysfs_int_and_verify(const char *filename, const char *basedir,
751 			       int val)
752 {
753 	return _write_sysfs_int(filename, basedir, val, 1);
754 }
755 
_write_sysfs_string(const char * filename,const char * basedir,const char * val,int verify)756 static int _write_sysfs_string(const char *filename, const char *basedir,
757 			       const char *val, int verify)
758 {
759 	int ret = 0;
760 	FILE  *sysfsfp;
761 	char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
762 
763 	if (!temp) {
764 		fprintf(stderr, "Memory allocation failed\n");
765 		return -ENOMEM;
766 	}
767 
768 	ret = sprintf(temp, "%s/%s", basedir, filename);
769 	if (ret < 0)
770 		goto error_free;
771 
772 	sysfsfp = fopen(temp, "w");
773 	if (!sysfsfp) {
774 		ret = -errno;
775 		fprintf(stderr, "Could not open %s\n", temp);
776 		goto error_free;
777 	}
778 
779 	ret = fprintf(sysfsfp, "%s", val);
780 	if (ret < 0) {
781 		if (fclose(sysfsfp))
782 			perror("_write_sysfs_string(): Failed to close dir");
783 
784 		goto error_free;
785 	}
786 
787 	if (fclose(sysfsfp)) {
788 		ret = -errno;
789 		goto error_free;
790 	}
791 
792 	if (verify) {
793 		sysfsfp = fopen(temp, "r");
794 		if (!sysfsfp) {
795 			ret = -errno;
796 			fprintf(stderr, "Could not open file to verify\n");
797 			goto error_free;
798 		}
799 
800 		if (fscanf(sysfsfp, "%s", temp) != 1) {
801 			ret = errno ? -errno : -ENODATA;
802 			if (fclose(sysfsfp))
803 				perror("_write_sysfs_string(): Failed to close dir");
804 
805 			goto error_free;
806 		}
807 
808 		if (fclose(sysfsfp)) {
809 			ret = -errno;
810 			goto error_free;
811 		}
812 
813 		if (strcmp(temp, val) != 0) {
814 			fprintf(stderr,
815 				"Possible failure in string write of %s "
816 				"Should be %s written to %s/%s\n", temp, val,
817 				basedir, filename);
818 			ret = -1;
819 		}
820 	}
821 
822 error_free:
823 	free(temp);
824 
825 	return ret;
826 }
827 
828 /**
829  * write_sysfs_string_and_verify() - string write, readback and verify
830  * @filename: name of file to write to
831  * @basedir: the sysfs directory in which the file is to be found
832  * @val: the string to write
833  *
834  * Returns a value >= 0 on success, otherwise a negative error code.
835  **/
write_sysfs_string_and_verify(const char * filename,const char * basedir,const char * val)836 int write_sysfs_string_and_verify(const char *filename, const char *basedir,
837 				  const char *val)
838 {
839 	return _write_sysfs_string(filename, basedir, val, 1);
840 }
841 
842 /**
843  * write_sysfs_string() - write string to a sysfs file
844  * @filename: name of file to write to
845  * @basedir: the sysfs directory in which the file is to be found
846  * @val: the string to write
847  *
848  * Returns a value >= 0 on success, otherwise a negative error code.
849  **/
write_sysfs_string(const char * filename,const char * basedir,const char * val)850 int write_sysfs_string(const char *filename, const char *basedir,
851 		       const char *val)
852 {
853 	return _write_sysfs_string(filename, basedir, val, 0);
854 }
855 
856 /**
857  * read_sysfs_posint() - read an integer value from file
858  * @filename: name of file to read from
859  * @basedir: the sysfs directory in which the file is to be found
860  *
861  * Returns the read integer value >= 0 on success, otherwise a negative error
862  * code.
863  **/
read_sysfs_posint(const char * filename,const char * basedir)864 int read_sysfs_posint(const char *filename, const char *basedir)
865 {
866 	int ret;
867 	FILE  *sysfsfp;
868 	char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
869 
870 	if (!temp) {
871 		fprintf(stderr, "Memory allocation failed");
872 		return -ENOMEM;
873 	}
874 
875 	ret = sprintf(temp, "%s/%s", basedir, filename);
876 	if (ret < 0)
877 		goto error_free;
878 
879 	sysfsfp = fopen(temp, "r");
880 	if (!sysfsfp) {
881 		ret = -errno;
882 		goto error_free;
883 	}
884 
885 	errno = 0;
886 	if (fscanf(sysfsfp, "%d\n", &ret) != 1) {
887 		ret = errno ? -errno : -ENODATA;
888 		if (fclose(sysfsfp))
889 			perror("read_sysfs_posint(): Failed to close dir");
890 
891 		goto error_free;
892 	}
893 
894 	if (fclose(sysfsfp))
895 		ret = -errno;
896 
897 error_free:
898 	free(temp);
899 
900 	return ret;
901 }
902 
903 /**
904  * read_sysfs_float() - read a float value from file
905  * @filename: name of file to read from
906  * @basedir: the sysfs directory in which the file is to be found
907  * @val: output the read float value
908  *
909  * Returns a value >= 0 on success, otherwise a negative error code.
910  **/
read_sysfs_float(const char * filename,const char * basedir,float * val)911 int read_sysfs_float(const char *filename, const char *basedir, float *val)
912 {
913 	int ret = 0;
914 	FILE  *sysfsfp;
915 	char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
916 
917 	if (!temp) {
918 		fprintf(stderr, "Memory allocation failed");
919 		return -ENOMEM;
920 	}
921 
922 	ret = sprintf(temp, "%s/%s", basedir, filename);
923 	if (ret < 0)
924 		goto error_free;
925 
926 	sysfsfp = fopen(temp, "r");
927 	if (!sysfsfp) {
928 		ret = -errno;
929 		goto error_free;
930 	}
931 
932 	errno = 0;
933 	if (fscanf(sysfsfp, "%f\n", val) != 1) {
934 		ret = errno ? -errno : -ENODATA;
935 		if (fclose(sysfsfp))
936 			perror("read_sysfs_float(): Failed to close dir");
937 
938 		goto error_free;
939 	}
940 
941 	if (fclose(sysfsfp))
942 		ret = -errno;
943 
944 error_free:
945 	free(temp);
946 
947 	return ret;
948 }
949 
950 /**
951  * read_sysfs_string() - read a string from file
952  * @filename: name of file to read from
953  * @basedir: the sysfs directory in which the file is to be found
954  * @str: output the read string
955  *
956  * Returns a value >= 0 on success, otherwise a negative error code.
957  **/
read_sysfs_string(const char * filename,const char * basedir,char * str)958 int read_sysfs_string(const char *filename, const char *basedir, char *str)
959 {
960 	int ret = 0;
961 	FILE  *sysfsfp;
962 	char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
963 
964 	if (!temp) {
965 		fprintf(stderr, "Memory allocation failed");
966 		return -ENOMEM;
967 	}
968 
969 	ret = sprintf(temp, "%s/%s", basedir, filename);
970 	if (ret < 0)
971 		goto error_free;
972 
973 	sysfsfp = fopen(temp, "r");
974 	if (!sysfsfp) {
975 		ret = -errno;
976 		goto error_free;
977 	}
978 
979 	errno = 0;
980 	if (fscanf(sysfsfp, "%s\n", str) != 1) {
981 		ret = errno ? -errno : -ENODATA;
982 		if (fclose(sysfsfp))
983 			perror("read_sysfs_string(): Failed to close dir");
984 
985 		goto error_free;
986 	}
987 
988 	if (fclose(sysfsfp))
989 		ret = -errno;
990 
991 error_free:
992 	free(temp);
993 
994 	return ret;
995 }
996