![Greg Kroah-Hartman](/assets/img/avatar_default.png)
A few bits for the counters subsystem mixed in here as well. There are some late breaking fixes as well, which aren't so urgent they can't wait for the merge window. New Device Support * adf4371 - New driver + bindings. - Support the adf4372 PLL. Mostly ID and bindings. * ad8366 (note includes rework of driver needed to allow support for these). - Support the ADL5240 variable gain amplifier (VGA). - Support the ADA4961 digital gain amplifier (DGA). * dps310 - New driver, in several parts from different authors for this temp and pressure sensor. - Includes errata workaround for a temperature reading issue. * stk3310 - Support the stk3335, mostly ID. Features and cleanups * core - drop error handling on debugfs registration. - harden by making sure we don't overrun iio_chan_info_postfix. * docs - convert remaining docs to rst. At somepoint we'll fit these few into the main IIO docs. - improve sampling_frequency_available docs but explaining the range form. * ad_sigma_delta - Drop a pointless goto. * ad2s1210 - Drop pointless platform data null check seeing as we don't actually use platform data anymore. * ad7124 - Relax limitation on channel numbers to allow pseudo different channels. - Support control of whether the input is buffered via DT. - Use dynamic allocation for channel configuration to make it easier to support new devices. - YAML binding conversion. * ad7150 - Comment tidy up. - Consistent and simple if (ret) handling of i2c errors. - FIELD_GET and GENMASK. - Ternary rather than !!(condition) for readability. - Use macros to avoid repetition of channel definitions. * ad7606 - Add software channel config (rather that pin controlled) - Refactor to simplify addition of new part in future. * ad7746 - of_deivce_id table. * ad7780 - MAINTAINERS entry - YAML DT bindings. * ad8366 - Stop using core mlock in favour of well scoped local lock. - SPDX + copyright date update. * ad9834 - of_device_id table * adf4371 - Add support for output stage muting before lock on has occured. * adis library - MAINTAINERS entry to reflect that this now Alexandru's problem ;) * adis162xx: - Fix a slightly incorrect set of comments and print statements on minimum supported voltage. * adis16203 - of_device_id table. * adis16240 - Add of_device_id table (in two parts as first patch only used it for MODULE_DEVICE_TABLE.) * adt7316-spi - of_device_id table * adxl372 - YAML DT binding conversion. - Cleanup use of buffer callback functions (precursor to core rework). * bh1710 - Simplify getting the i2c adapter from the client. * dht11 - Mote to newer GPIO consumer interface. * kxcjk-1013.c - Add binding for sensor in display of some ultrabooks after userspace tools updated for it not be a problem to report two similar sensors. * imx7d - drop unused variables. - white space - define instead of variable for clock frequency that is fixed. - drop pointless error message. * messon_saradc - SPDX * sps30 - MAINTAINERS entry - YAML binding conversion. * st_accel - Tidy up ordering in various buffer related callbacks. This is part of a long running effort to simplify the core code. * stm32-dfsdm: - Manage the resolution cleanly in triggerd modes. - Add fast mode support which allows more flexible filter choices. - Add a comment on the reason for a 16 bit record when technically not 'required'. * st_lsm6dsx - Embed device name in the sensor_settings struct as i3c doesn't have a convenient name field to use for this. * xilinx-adc - Relax constraints on supported platforms to reflect that this can used with FPGAs on PCIe cards and hence many architectures. * counters/ftm-quaddec - Fix some formatting io MODULE_AUTHOR - MAINTAINERS entry Fixes * tools - fix incorrect handling of 32 bit channels. * sca3000 - Potential endian bug that is unlikely to bite anyone (be64 host seems unlikely for this old part). * stm32-adc - Add vdda-supply. On some boards it needs to be turned on to supply the ADC. DT bindings included. * stm32-dfsdm - Fix output resolution to work with filter orders other than 3. - Fix output datatype as it's signed and previously claimed not to be. -----BEGIN PGP SIGNATURE----- iQJFBAABCAAvFiEEbilms4eEBlKRJoGxVIU0mcT0FogFAl0VHIkRHGppYzIzQGtl cm5lbC5vcmcACgkQVIU0mcT0FojyxhAAgrLRy2wlHjQCAh0S6J22LKs02uPX1qvY nm1aI/av2DGcMCV2NF6J1sW2Mocvtt5a79/1f/wRqDzOHBrTpFr0Q0Ngwijv9bzc fv6NwfHlWolmXynKx8wK4b6Sa3KVCkltojEVpEVbhkuMkafSQ+pQzYF1Uf7enOrX j3Gq6NYaCks4YtFZsBphgzo3DC0mh7CfunlPiOdVcgcg4Pj/KZY9QCX86fJx972x YI3BRFHnDSMDOxOTjeqeKvMiqU2zLPlqLSEOCUw2XCrh6HI9qFiU+LVsYx6SP0tx aJ2q+qYc9raOTANHk7O2JZYWv/52JXvtKcFSLiuQdABjaAI20xEr1QAZYVYUiXmg dFH6lBsWvQyAy5F/SyZ5tavZvTfGsNDB5LhlpEggeO2W6cIIL4CLfHimB2EcxFSH utqEA72HQZosEUKut1jbmG6iYMiRnHS72pLOqkJ6HC/2/pZfoEWlEH9x/S3xbBsW 918ISs9852VwjebQwck96+Dh0LwiKOl8Aii5ONzfNObJB6/JbULPoKKArsMdENQA mqDXLOMz6GspY3JgiVDCXAwg2x2Ht/ictR6svRJtOTLiBU2Iybpm/HRkPePhoePF HLw8fhwE+mOSWr22KhzjUJBHEAkoejo/14XOgKSTkO9V6amLlOWRDV3uK2PksmdI 7DQyYhX9Tos= =a3vh -----END PGP SIGNATURE----- Merge tag 'iio-for-5.3b' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next Jonathan writes: Second set of IIO device support, features, cleanups and minor fixes for 5.3. A few bits for the counters subsystem mixed in here as well. There are some late breaking fixes as well, which aren't so urgent they can't wait for the merge window. New Device Support * adf4371 - New driver + bindings. - Support the adf4372 PLL. Mostly ID and bindings. * ad8366 (note includes rework of driver needed to allow support for these). - Support the ADL5240 variable gain amplifier (VGA). - Support the ADA4961 digital gain amplifier (DGA). * dps310 - New driver, in several parts from different authors for this temp and pressure sensor. - Includes errata workaround for a temperature reading issue. * stk3310 - Support the stk3335, mostly ID. Features and cleanups * core - drop error handling on debugfs registration. - harden by making sure we don't overrun iio_chan_info_postfix. * docs - convert remaining docs to rst. At somepoint we'll fit these few into the main IIO docs. - improve sampling_frequency_available docs but explaining the range form. * ad_sigma_delta - Drop a pointless goto. * ad2s1210 - Drop pointless platform data null check seeing as we don't actually use platform data anymore. * ad7124 - Relax limitation on channel numbers to allow pseudo different channels. - Support control of whether the input is buffered via DT. - Use dynamic allocation for channel configuration to make it easier to support new devices. - YAML binding conversion. * ad7150 - Comment tidy up. - Consistent and simple if (ret) handling of i2c errors. - FIELD_GET and GENMASK. - Ternary rather than !!(condition) for readability. - Use macros to avoid repetition of channel definitions. * ad7606 - Add software channel config (rather that pin controlled) - Refactor to simplify addition of new part in future. * ad7746 - of_deivce_id table. * ad7780 - MAINTAINERS entry - YAML DT bindings. * ad8366 - Stop using core mlock in favour of well scoped local lock. - SPDX + copyright date update. * ad9834 - of_device_id table * adf4371 - Add support for output stage muting before lock on has occured. * adis library - MAINTAINERS entry to reflect that this now Alexandru's problem ;) * adis162xx: - Fix a slightly incorrect set of comments and print statements on minimum supported voltage. * adis16203 - of_device_id table. * adis16240 - Add of_device_id table (in two parts as first patch only used it for MODULE_DEVICE_TABLE.) * adt7316-spi - of_device_id table * adxl372 - YAML DT binding conversion. - Cleanup use of buffer callback functions (precursor to core rework). * bh1710 - Simplify getting the i2c adapter from the client. * dht11 - Mote to newer GPIO consumer interface. * kxcjk-1013.c - Add binding for sensor in display of some ultrabooks after userspace tools updated for it not be a problem to report two similar sensors. * imx7d - drop unused variables. - white space - define instead of variable for clock frequency that is fixed. - drop pointless error message. * messon_saradc - SPDX * sps30 - MAINTAINERS entry - YAML binding conversion. * st_accel - Tidy up ordering in various buffer related callbacks. This is part of a long running effort to simplify the core code. * stm32-dfsdm: - Manage the resolution cleanly in triggerd modes. - Add fast mode support which allows more flexible filter choices. - Add a comment on the reason for a 16 bit record when technically not 'required'. * st_lsm6dsx - Embed device name in the sensor_settings struct as i3c doesn't have a convenient name field to use for this. * xilinx-adc - Relax constraints on supported platforms to reflect that this can used with FPGAs on PCIe cards and hence many architectures. * counters/ftm-quaddec - Fix some formatting io MODULE_AUTHOR - MAINTAINERS entry Fixes * tools - fix incorrect handling of 32 bit channels. * sca3000 - Potential endian bug that is unlikely to bite anyone (be64 host seems unlikely for this old part). * stm32-adc - Add vdda-supply. On some boards it needs to be turned on to supply the ADC. DT bindings included. * stm32-dfsdm - Fix output resolution to work with filter orders other than 3. - Fix output datatype as it's signed and previously claimed not to be. * tag 'iio-for-5.3b' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio: (68 commits) iio: iio-utils: Fix possible incorrect mask calculation iio: frequency: adf4371: Add support for output stage mute dt-bindings: iio: frequency: Add ADF4372 PLL documentation iio: frequency: adf4371: Add support for ADF4372 PLL dt-bindings: iio: adc: Add buffered input property Convert AD7124 bindings documentation to YAML format. iio: adc: ad7124: Shift to dynamic allocation for channel configuration iio: adc: ad7124: Add buffered input support iio: adc: ad7124: Remove input number limitation MAINTAINERS: add ADIS IMU driver library entry iio: adis162xx: fix low-power docs & reports counter/ftm-quaddec: Add missing '>' in MODULE_AUTHOR iio: core: no need to check return value of debugfs_create functions docs: iio: convert to ReST iio: adc: stm32-adc: add missing vdda-supply dt-bindings: iio: adc: stm32: add missing vdda supply iio: adc: stm32-dfsdm: add comment for 16 bits record iio: adc: stm32-dfsdm: add fast mode support iio: adc: stm32-dfsdm: manage data resolution in trigger mode iio: adc: stm32-dfsdm: fix data type ...
992 lines
21 KiB
C
992 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/* IIO - useful set of util functionality
|
|
*
|
|
* Copyright (c) 2008 Jonathan Cameron
|
|
*/
|
|
#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 = ~(0ULL);
|
|
else
|
|
*mask = (1ULL << *bits_used) - 1ULL;
|
|
|
|
*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;
|
|
}
|