mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-30 08:02:30 +00:00
6356f1b9b7
Now there are channel modifiers with their own scaling those should be used when possible over the generic channel type scaling. Examples are of IIO_TEMP channel having a generic scaling value, and another having IIO_MOD_TEMP_AMBIENT modifier with another scaling value. Previously the first scaling value for a channel type would be applied to all channels of like type in iio_generic_buffer Signed-off-by: Matt Ranostay <mranostay@gmail.com> Signed-off-by: Jonathan Cameron <jic23@kernel.org>
994 lines
21 KiB
C
994 lines
21 KiB
C
/* IIO - useful set of util functionality
|
|
*
|
|
* Copyright (c) 2008 Jonathan Cameron
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 as published by
|
|
* the Free Software Foundation.
|
|
*/
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include "iio_utils.h"
|
|
|
|
const char *iio_dir = "/sys/bus/iio/devices/";
|
|
|
|
static char * const iio_direction[] = {
|
|
"in",
|
|
"out",
|
|
};
|
|
|
|
/**
|
|
* iioutils_break_up_name() - extract generic name from full channel name
|
|
* @full_name: the full channel name
|
|
* @generic_name: the output generic channel name
|
|
*
|
|
* Returns 0 on success, or a negative error code if string extraction failed.
|
|
**/
|
|
int iioutils_break_up_name(const char *full_name, char **generic_name)
|
|
{
|
|
char *current;
|
|
char *w, *r;
|
|
char *working, *prefix = "";
|
|
int i, ret;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(iio_direction); i++)
|
|
if (!strncmp(full_name, iio_direction[i],
|
|
strlen(iio_direction[i]))) {
|
|
prefix = iio_direction[i];
|
|
break;
|
|
}
|
|
|
|
current = strdup(full_name + strlen(prefix) + 1);
|
|
if (!current)
|
|
return -ENOMEM;
|
|
|
|
working = strtok(current, "_\0");
|
|
if (!working) {
|
|
free(current);
|
|
return -EINVAL;
|
|
}
|
|
|
|
w = working;
|
|
r = working;
|
|
|
|
while (*r != '\0') {
|
|
if (!isdigit(*r)) {
|
|
*w = *r;
|
|
w++;
|
|
}
|
|
|
|
r++;
|
|
}
|
|
*w = '\0';
|
|
ret = asprintf(generic_name, "%s_%s", prefix, working);
|
|
free(current);
|
|
|
|
return (ret == -1) ? -ENOMEM : 0;
|
|
}
|
|
|
|
/**
|
|
* iioutils_get_type() - find and process _type attribute data
|
|
* @is_signed: output whether channel is signed
|
|
* @bytes: output how many bytes the channel storage occupies
|
|
* @bits_used: output number of valid bits of data
|
|
* @shift: output amount of bits to shift right data before applying bit mask
|
|
* @mask: output a bit mask for the raw data
|
|
* @be: output if data in big endian
|
|
* @device_dir: the IIO device directory
|
|
* @name: the channel name
|
|
* @generic_name: the channel type name
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int iioutils_get_type(unsigned *is_signed, unsigned *bytes, unsigned *bits_used,
|
|
unsigned *shift, uint64_t *mask, unsigned *be,
|
|
const char *device_dir, const char *name,
|
|
const char *generic_name)
|
|
{
|
|
FILE *sysfsfp;
|
|
int ret;
|
|
DIR *dp;
|
|
char *scan_el_dir, *builtname, *builtname_generic, *filename = 0;
|
|
char signchar, endianchar;
|
|
unsigned padint;
|
|
const struct dirent *ent;
|
|
|
|
ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir);
|
|
if (ret < 0)
|
|
return -ENOMEM;
|
|
|
|
ret = asprintf(&builtname, FORMAT_TYPE_FILE, name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_free_scan_el_dir;
|
|
}
|
|
ret = asprintf(&builtname_generic, FORMAT_TYPE_FILE, generic_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_free_builtname;
|
|
}
|
|
|
|
dp = opendir(scan_el_dir);
|
|
if (!dp) {
|
|
ret = -errno;
|
|
goto error_free_builtname_generic;
|
|
}
|
|
|
|
ret = -ENOENT;
|
|
while (ent = readdir(dp), ent)
|
|
if ((strcmp(builtname, ent->d_name) == 0) ||
|
|
(strcmp(builtname_generic, ent->d_name) == 0)) {
|
|
ret = asprintf(&filename,
|
|
"%s/%s", scan_el_dir, ent->d_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_closedir;
|
|
}
|
|
|
|
sysfsfp = fopen(filename, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "failed to open %s\n",
|
|
filename);
|
|
goto error_free_filename;
|
|
}
|
|
|
|
ret = fscanf(sysfsfp,
|
|
"%ce:%c%u/%u>>%u",
|
|
&endianchar,
|
|
&signchar,
|
|
bits_used,
|
|
&padint, shift);
|
|
if (ret < 0) {
|
|
ret = -errno;
|
|
fprintf(stderr,
|
|
"failed to pass scan type description\n");
|
|
goto error_close_sysfsfp;
|
|
} else if (ret != 5) {
|
|
ret = -EIO;
|
|
fprintf(stderr,
|
|
"scan type description didn't match\n");
|
|
goto error_close_sysfsfp;
|
|
}
|
|
|
|
*be = (endianchar == 'b');
|
|
*bytes = padint / 8;
|
|
if (*bits_used == 64)
|
|
*mask = ~0;
|
|
else
|
|
*mask = (1ULL << *bits_used) - 1;
|
|
|
|
*is_signed = (signchar == 's');
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
fprintf(stderr, "Failed to close %s\n",
|
|
filename);
|
|
goto error_free_filename;
|
|
}
|
|
|
|
sysfsfp = 0;
|
|
free(filename);
|
|
filename = 0;
|
|
|
|
/*
|
|
* Avoid having a more generic entry overwriting
|
|
* the settings.
|
|
*/
|
|
if (strcmp(builtname, ent->d_name) == 0)
|
|
break;
|
|
}
|
|
|
|
error_close_sysfsfp:
|
|
if (sysfsfp)
|
|
if (fclose(sysfsfp))
|
|
perror("iioutils_get_type(): Failed to close file");
|
|
|
|
error_free_filename:
|
|
if (filename)
|
|
free(filename);
|
|
|
|
error_closedir:
|
|
if (closedir(dp) == -1)
|
|
perror("iioutils_get_type(): Failed to close directory");
|
|
|
|
error_free_builtname_generic:
|
|
free(builtname_generic);
|
|
error_free_builtname:
|
|
free(builtname);
|
|
error_free_scan_el_dir:
|
|
free(scan_el_dir);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* iioutils_get_param_float() - read a float value from a channel parameter
|
|
* @output: output the float value
|
|
* @param_name: the parameter name to read
|
|
* @device_dir: the IIO device directory in sysfs
|
|
* @name: the channel name
|
|
* @generic_name: the channel type name
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int iioutils_get_param_float(float *output, const char *param_name,
|
|
const char *device_dir, const char *name,
|
|
const char *generic_name)
|
|
{
|
|
FILE *sysfsfp;
|
|
int ret;
|
|
DIR *dp;
|
|
char *builtname, *builtname_generic;
|
|
char *filename = NULL;
|
|
const struct dirent *ent;
|
|
|
|
ret = asprintf(&builtname, "%s_%s", name, param_name);
|
|
if (ret < 0)
|
|
return -ENOMEM;
|
|
|
|
ret = asprintf(&builtname_generic,
|
|
"%s_%s", generic_name, param_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_free_builtname;
|
|
}
|
|
|
|
dp = opendir(device_dir);
|
|
if (!dp) {
|
|
ret = -errno;
|
|
goto error_free_builtname_generic;
|
|
}
|
|
|
|
ret = -ENOENT;
|
|
while (ent = readdir(dp), ent)
|
|
if ((strcmp(builtname, ent->d_name) == 0) ||
|
|
(strcmp(builtname_generic, ent->d_name) == 0)) {
|
|
ret = asprintf(&filename,
|
|
"%s/%s", device_dir, ent->d_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_closedir;
|
|
}
|
|
|
|
sysfsfp = fopen(filename, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
goto error_free_filename;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%f", output) != 1)
|
|
ret = errno ? -errno : -ENODATA;
|
|
|
|
break;
|
|
}
|
|
error_free_filename:
|
|
if (filename)
|
|
free(filename);
|
|
|
|
error_closedir:
|
|
if (closedir(dp) == -1)
|
|
perror("iioutils_get_param_float(): Failed to close directory");
|
|
|
|
error_free_builtname_generic:
|
|
free(builtname_generic);
|
|
error_free_builtname:
|
|
free(builtname);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* bsort_channel_array_by_index() - sort the array in index order
|
|
* @ci_array: the iio_channel_info array to be sorted
|
|
* @cnt: the amount of array elements
|
|
**/
|
|
|
|
void bsort_channel_array_by_index(struct iio_channel_info *ci_array, int cnt)
|
|
{
|
|
struct iio_channel_info temp;
|
|
int x, y;
|
|
|
|
for (x = 0; x < cnt; x++)
|
|
for (y = 0; y < (cnt - 1); y++)
|
|
if (ci_array[y].index > ci_array[y + 1].index) {
|
|
temp = ci_array[y + 1];
|
|
ci_array[y + 1] = ci_array[y];
|
|
ci_array[y] = temp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* build_channel_array() - function to figure out what channels are present
|
|
* @device_dir: the IIO device directory in sysfs
|
|
* @ci_array: output the resulting array of iio_channel_info
|
|
* @counter: output the amount of array elements
|
|
*
|
|
* Returns 0 on success, otherwise a negative error code.
|
|
**/
|
|
int build_channel_array(const char *device_dir,
|
|
struct iio_channel_info **ci_array, int *counter)
|
|
{
|
|
DIR *dp;
|
|
FILE *sysfsfp;
|
|
int count = 0, i;
|
|
struct iio_channel_info *current;
|
|
int ret;
|
|
const struct dirent *ent;
|
|
char *scan_el_dir;
|
|
char *filename;
|
|
|
|
*counter = 0;
|
|
ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir);
|
|
if (ret < 0)
|
|
return -ENOMEM;
|
|
|
|
dp = opendir(scan_el_dir);
|
|
if (!dp) {
|
|
ret = -errno;
|
|
goto error_free_name;
|
|
}
|
|
|
|
while (ent = readdir(dp), ent)
|
|
if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"),
|
|
"_en") == 0) {
|
|
ret = asprintf(&filename,
|
|
"%s/%s", scan_el_dir, ent->d_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
goto error_close_dir;
|
|
}
|
|
|
|
sysfsfp = fopen(filename, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
free(filename);
|
|
goto error_close_dir;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%i", &ret) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("build_channel_array(): Failed to close file");
|
|
|
|
free(filename);
|
|
goto error_close_dir;
|
|
}
|
|
if (ret == 1)
|
|
(*counter)++;
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
free(filename);
|
|
goto error_close_dir;
|
|
}
|
|
|
|
free(filename);
|
|
}
|
|
|
|
*ci_array = malloc(sizeof(**ci_array) * (*counter));
|
|
if (!*ci_array) {
|
|
ret = -ENOMEM;
|
|
goto error_close_dir;
|
|
}
|
|
|
|
seekdir(dp, 0);
|
|
while (ent = readdir(dp), ent) {
|
|
if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"),
|
|
"_en") == 0) {
|
|
int current_enabled = 0;
|
|
|
|
current = &(*ci_array)[count++];
|
|
ret = asprintf(&filename,
|
|
"%s/%s", scan_el_dir, ent->d_name);
|
|
if (ret < 0) {
|
|
ret = -ENOMEM;
|
|
/* decrement count to avoid freeing name */
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
sysfsfp = fopen(filename, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
free(filename);
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%i", ¤t_enabled) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
free(filename);
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
free(filename);
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
if (!current_enabled) {
|
|
free(filename);
|
|
count--;
|
|
continue;
|
|
}
|
|
|
|
current->scale = 1.0;
|
|
current->offset = 0;
|
|
current->name = strndup(ent->d_name,
|
|
strlen(ent->d_name) -
|
|
strlen("_en"));
|
|
if (!current->name) {
|
|
free(filename);
|
|
ret = -ENOMEM;
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
/* Get the generic and specific name elements */
|
|
ret = iioutils_break_up_name(current->name,
|
|
¤t->generic_name);
|
|
if (ret) {
|
|
free(filename);
|
|
free(current->name);
|
|
count--;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
ret = asprintf(&filename,
|
|
"%s/%s_index",
|
|
scan_el_dir,
|
|
current->name);
|
|
if (ret < 0) {
|
|
free(filename);
|
|
ret = -ENOMEM;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
sysfsfp = fopen(filename, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "failed to open %s\n",
|
|
filename);
|
|
free(filename);
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%u", ¤t->index) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("build_channel_array(): Failed to close file");
|
|
|
|
free(filename);
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
free(filename);
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
free(filename);
|
|
/* Find the scale */
|
|
ret = iioutils_get_param_float(¤t->scale,
|
|
"scale",
|
|
device_dir,
|
|
current->name,
|
|
current->generic_name);
|
|
if ((ret < 0) && (ret != -ENOENT))
|
|
goto error_cleanup_array;
|
|
|
|
ret = iioutils_get_param_float(¤t->offset,
|
|
"offset",
|
|
device_dir,
|
|
current->name,
|
|
current->generic_name);
|
|
if ((ret < 0) && (ret != -ENOENT))
|
|
goto error_cleanup_array;
|
|
|
|
ret = iioutils_get_type(¤t->is_signed,
|
|
¤t->bytes,
|
|
¤t->bits_used,
|
|
¤t->shift,
|
|
¤t->mask,
|
|
¤t->be,
|
|
device_dir,
|
|
current->name,
|
|
current->generic_name);
|
|
if (ret < 0)
|
|
goto error_cleanup_array;
|
|
}
|
|
}
|
|
|
|
if (closedir(dp) == -1) {
|
|
ret = -errno;
|
|
goto error_cleanup_array;
|
|
}
|
|
|
|
free(scan_el_dir);
|
|
/* reorder so that the array is in index order */
|
|
bsort_channel_array_by_index(*ci_array, *counter);
|
|
|
|
return 0;
|
|
|
|
error_cleanup_array:
|
|
for (i = count - 1; i >= 0; i--) {
|
|
free((*ci_array)[i].name);
|
|
free((*ci_array)[i].generic_name);
|
|
}
|
|
free(*ci_array);
|
|
*ci_array = NULL;
|
|
*counter = 0;
|
|
error_close_dir:
|
|
if (dp)
|
|
if (closedir(dp) == -1)
|
|
perror("build_channel_array(): Failed to close dir");
|
|
|
|
error_free_name:
|
|
free(scan_el_dir);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int calc_digits(int num)
|
|
{
|
|
int count = 0;
|
|
|
|
while (num != 0) {
|
|
num /= 10;
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* find_type_by_name() - function to match top level types by name
|
|
* @name: top level type instance name
|
|
* @type: the type of top level instance being searched
|
|
*
|
|
* Returns the device number of a matched IIO device on success, otherwise a
|
|
* negative error code.
|
|
* Typical types this is used for are device and trigger.
|
|
**/
|
|
int find_type_by_name(const char *name, const char *type)
|
|
{
|
|
const struct dirent *ent;
|
|
int number, numstrlen, ret;
|
|
|
|
FILE *namefp;
|
|
DIR *dp;
|
|
char thisname[IIO_MAX_NAME_LENGTH];
|
|
char *filename;
|
|
|
|
dp = opendir(iio_dir);
|
|
if (!dp) {
|
|
fprintf(stderr, "No industrialio devices available\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
while (ent = readdir(dp), ent) {
|
|
if (strcmp(ent->d_name, ".") != 0 &&
|
|
strcmp(ent->d_name, "..") != 0 &&
|
|
strlen(ent->d_name) > strlen(type) &&
|
|
strncmp(ent->d_name, type, strlen(type)) == 0) {
|
|
errno = 0;
|
|
ret = sscanf(ent->d_name + strlen(type), "%d", &number);
|
|
if (ret < 0) {
|
|
ret = -errno;
|
|
fprintf(stderr,
|
|
"failed to read element number\n");
|
|
goto error_close_dir;
|
|
} else if (ret != 1) {
|
|
ret = -EIO;
|
|
fprintf(stderr,
|
|
"failed to match element number\n");
|
|
goto error_close_dir;
|
|
}
|
|
|
|
numstrlen = calc_digits(number);
|
|
/* verify the next character is not a colon */
|
|
if (strncmp(ent->d_name + strlen(type) + numstrlen,
|
|
":", 1) != 0) {
|
|
filename = malloc(strlen(iio_dir) + strlen(type)
|
|
+ numstrlen + 6);
|
|
if (!filename) {
|
|
ret = -ENOMEM;
|
|
goto error_close_dir;
|
|
}
|
|
|
|
ret = sprintf(filename, "%s%s%d/name", iio_dir,
|
|
type, number);
|
|
if (ret < 0) {
|
|
free(filename);
|
|
goto error_close_dir;
|
|
}
|
|
|
|
namefp = fopen(filename, "r");
|
|
if (!namefp) {
|
|
free(filename);
|
|
continue;
|
|
}
|
|
|
|
free(filename);
|
|
errno = 0;
|
|
if (fscanf(namefp, "%s", thisname) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
goto error_close_dir;
|
|
}
|
|
|
|
if (fclose(namefp)) {
|
|
ret = -errno;
|
|
goto error_close_dir;
|
|
}
|
|
|
|
if (strcmp(name, thisname) == 0) {
|
|
if (closedir(dp) == -1)
|
|
return -errno;
|
|
|
|
return number;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (closedir(dp) == -1)
|
|
return -errno;
|
|
|
|
return -ENODEV;
|
|
|
|
error_close_dir:
|
|
if (closedir(dp) == -1)
|
|
perror("find_type_by_name(): Failed to close directory");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int _write_sysfs_int(const char *filename, const char *basedir, int val,
|
|
int verify)
|
|
{
|
|
int ret = 0;
|
|
FILE *sysfsfp;
|
|
int test;
|
|
char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
|
|
|
|
if (!temp)
|
|
return -ENOMEM;
|
|
|
|
ret = sprintf(temp, "%s/%s", basedir, filename);
|
|
if (ret < 0)
|
|
goto error_free;
|
|
|
|
sysfsfp = fopen(temp, "w");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "failed to open %s\n", temp);
|
|
goto error_free;
|
|
}
|
|
|
|
ret = fprintf(sysfsfp, "%d", val);
|
|
if (ret < 0) {
|
|
if (fclose(sysfsfp))
|
|
perror("_write_sysfs_int(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
if (verify) {
|
|
sysfsfp = fopen(temp, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "failed to open %s\n", temp);
|
|
goto error_free;
|
|
}
|
|
|
|
if (fscanf(sysfsfp, "%d", &test) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("_write_sysfs_int(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
if (test != val) {
|
|
fprintf(stderr,
|
|
"Possible failure in int write %d to %s/%s\n",
|
|
val, basedir, filename);
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
error_free:
|
|
free(temp);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* write_sysfs_int() - write an integer value to a sysfs file
|
|
* @filename: name of the file to write to
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @val: integer value to write to file
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int write_sysfs_int(const char *filename, const char *basedir, int val)
|
|
{
|
|
return _write_sysfs_int(filename, basedir, val, 0);
|
|
}
|
|
|
|
/**
|
|
* write_sysfs_int_and_verify() - write an integer value to a sysfs file
|
|
* and verify
|
|
* @filename: name of the file to write to
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @val: integer value to write to file
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int write_sysfs_int_and_verify(const char *filename, const char *basedir,
|
|
int val)
|
|
{
|
|
return _write_sysfs_int(filename, basedir, val, 1);
|
|
}
|
|
|
|
static int _write_sysfs_string(const char *filename, const char *basedir,
|
|
const char *val, int verify)
|
|
{
|
|
int ret = 0;
|
|
FILE *sysfsfp;
|
|
char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
|
|
|
|
if (!temp) {
|
|
fprintf(stderr, "Memory allocation failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = sprintf(temp, "%s/%s", basedir, filename);
|
|
if (ret < 0)
|
|
goto error_free;
|
|
|
|
sysfsfp = fopen(temp, "w");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "Could not open %s\n", temp);
|
|
goto error_free;
|
|
}
|
|
|
|
ret = fprintf(sysfsfp, "%s", val);
|
|
if (ret < 0) {
|
|
if (fclose(sysfsfp))
|
|
perror("_write_sysfs_string(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
if (verify) {
|
|
sysfsfp = fopen(temp, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
fprintf(stderr, "Could not open file to verify\n");
|
|
goto error_free;
|
|
}
|
|
|
|
if (fscanf(sysfsfp, "%s", temp) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("_write_sysfs_string(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp)) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
if (strcmp(temp, val) != 0) {
|
|
fprintf(stderr,
|
|
"Possible failure in string write of %s "
|
|
"Should be %s written to %s/%s\n", temp, val,
|
|
basedir, filename);
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
error_free:
|
|
free(temp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* write_sysfs_string_and_verify() - string write, readback and verify
|
|
* @filename: name of file to write to
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @val: the string to write
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int write_sysfs_string_and_verify(const char *filename, const char *basedir,
|
|
const char *val)
|
|
{
|
|
return _write_sysfs_string(filename, basedir, val, 1);
|
|
}
|
|
|
|
/**
|
|
* write_sysfs_string() - write string to a sysfs file
|
|
* @filename: name of file to write to
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @val: the string to write
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int write_sysfs_string(const char *filename, const char *basedir,
|
|
const char *val)
|
|
{
|
|
return _write_sysfs_string(filename, basedir, val, 0);
|
|
}
|
|
|
|
/**
|
|
* read_sysfs_posint() - read an integer value from file
|
|
* @filename: name of file to read from
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
*
|
|
* Returns the read integer value >= 0 on success, otherwise a negative error
|
|
* code.
|
|
**/
|
|
int read_sysfs_posint(const char *filename, const char *basedir)
|
|
{
|
|
int ret;
|
|
FILE *sysfsfp;
|
|
char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
|
|
|
|
if (!temp) {
|
|
fprintf(stderr, "Memory allocation failed");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = sprintf(temp, "%s/%s", basedir, filename);
|
|
if (ret < 0)
|
|
goto error_free;
|
|
|
|
sysfsfp = fopen(temp, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%d\n", &ret) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("read_sysfs_posint(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp))
|
|
ret = -errno;
|
|
|
|
error_free:
|
|
free(temp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* read_sysfs_float() - read a float value from file
|
|
* @filename: name of file to read from
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @val: output the read float value
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int read_sysfs_float(const char *filename, const char *basedir, float *val)
|
|
{
|
|
int ret = 0;
|
|
FILE *sysfsfp;
|
|
char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
|
|
|
|
if (!temp) {
|
|
fprintf(stderr, "Memory allocation failed");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = sprintf(temp, "%s/%s", basedir, filename);
|
|
if (ret < 0)
|
|
goto error_free;
|
|
|
|
sysfsfp = fopen(temp, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%f\n", val) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("read_sysfs_float(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp))
|
|
ret = -errno;
|
|
|
|
error_free:
|
|
free(temp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* read_sysfs_string() - read a string from file
|
|
* @filename: name of file to read from
|
|
* @basedir: the sysfs directory in which the file is to be found
|
|
* @str: output the read string
|
|
*
|
|
* Returns a value >= 0 on success, otherwise a negative error code.
|
|
**/
|
|
int read_sysfs_string(const char *filename, const char *basedir, char *str)
|
|
{
|
|
int ret = 0;
|
|
FILE *sysfsfp;
|
|
char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
|
|
|
|
if (!temp) {
|
|
fprintf(stderr, "Memory allocation failed");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = sprintf(temp, "%s/%s", basedir, filename);
|
|
if (ret < 0)
|
|
goto error_free;
|
|
|
|
sysfsfp = fopen(temp, "r");
|
|
if (!sysfsfp) {
|
|
ret = -errno;
|
|
goto error_free;
|
|
}
|
|
|
|
errno = 0;
|
|
if (fscanf(sysfsfp, "%s\n", str) != 1) {
|
|
ret = errno ? -errno : -ENODATA;
|
|
if (fclose(sysfsfp))
|
|
perror("read_sysfs_string(): Failed to close dir");
|
|
|
|
goto error_free;
|
|
}
|
|
|
|
if (fclose(sysfsfp))
|
|
ret = -errno;
|
|
|
|
error_free:
|
|
free(temp);
|
|
|
|
return ret;
|
|
}
|