linux-stable/tools/iio/iio_utils.c
Matt Ranostay 6356f1b9b7 iio: iio-utils: use channel modifier scaling if it exists
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>
2016-08-29 16:26:41 +01:00

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", &current_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,
&current->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", &current->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(&current->scale,
"scale",
device_dir,
current->name,
current->generic_name);
if ((ret < 0) && (ret != -ENOENT))
goto error_cleanup_array;
ret = iioutils_get_param_float(&current->offset,
"offset",
device_dir,
current->name,
current->generic_name);
if ((ret < 0) && (ret != -ENOENT))
goto error_cleanup_array;
ret = iioutils_get_type(&current->is_signed,
&current->bytes,
&current->bits_used,
&current->shift,
&current->mask,
&current->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;
}