drivers/staging/iio/Documentation/iio_utils.h

   1 /* IIO - useful set of util functionality
   2  *
   3  * Copyright (c) 2008 Jonathan Cameron
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 /* Made up value to limit allocation sizes */
  11 #include <string.h>
  12 #include <stdlib.h>
  13
  14 #define IIO_MAX_NAME_LENGTH 30
  15
  16 #define IIO_EVENT_CODE_RING_50_FULL 200
  17 #define IIO_EVENT_CODE_RING_75_FULL 201
  18 #define IIO_EVENT_CODE_RING_100_FULL 202
  19
  20 const char *iio_dir = "/sys/bus/iio/devices/";
  21
  22 struct iio_event_data {
  23         int id;
  24         __s64 timestamp;
  25 };
  26
  27 /**
  28  * find_type_by_name() - function to match top level types by name
  29  * @name: top level type instance name
  30  * @type: the type of top level instance being sort
  31  *
  32  * Typical types this is used for are device and trigger.
  33  **/
  34 inline int find_type_by_name(const char *name, const char *type)
  35 {
  36         const struct dirent *ent;
  37         int number, numstrlen;
  38
  39         FILE *nameFile;
  40         DIR *dp;
  41         char thisname[IIO_MAX_NAME_LENGTH];
  42         char *filename;
  43         struct stat Stat;
  44
  45         dp = opendir(iio_dir);
  46         if (dp == NULL) {
  47                 printf("No industrialio devices available");
  48                 return -ENODEV;
  49         }
  50
  51         while (ent = readdir(dp), ent != NULL) {
  52                 if (strcmp(ent->d_name, ".") != 0 &&
  53                         strcmp(ent->d_name, "..") != 0 &&
  54                         strlen(ent->d_name) > strlen(type) &&
  55                         strncmp(ent->d_name, type, strlen(type)) == 0) {
  56                         numstrlen = sscanf(ent->d_name + strlen(type),
  57                                            "%d",
  58                                            &number);
  59                         /* verify the next character is not a colon */
  60                         if (strncmp(ent->d_name + strlen(type) + numstrlen,
  61                                         ":",
  62                                         1) != 0) {
  63                                 filename = malloc(strlen(iio_dir)
  64                                                 + strlen(type)
  65                                                 + 1
  66                                                 + numstrlen
  67                                                 + 1);
  68                                 if (filename == NULL)
  69                                         return -ENOMEM;
  70                                 sprintf(filename, "%s%s%d/name",
  71                                         iio_dir,
  72                                         type,
  73                                         number);
  74                                 nameFile = fopen(filename, "r");
  75                                 if (!nameFile)
  76                                         continue;
  77                                 free(filename);
  78                                 fscanf(nameFile, "%s", thisname);
  79                                 if (strcmp(name, thisname) == 0)
  80                                         return number;
  81                                 fclose(nameFile);
  82                         }
  83                 }
  84         }
  85         return -ENODEV;
  86 }
  87
  88 inline int _write_sysfs_int(char *filename, char *basedir, int val, int verify)
  89 {
  90         int ret;
  91         FILE *sysfsfp;
  92         int test;
  93         char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
  94         if (temp == NULL)
  95                 return -ENOMEM;
  96         sprintf(temp, "%s/%s", basedir, filename);
  97         sysfsfp = fopen(temp, "w");
  98         if (sysfsfp == NULL) {
  99                 printf("failed to open %s\n", temp);
 100                 ret = -errno;
 101                 goto error_free;
 102         }
 103         fprintf(sysfsfp, "%d", val);
 104         fclose(sysfsfp);
 105         if (verify) {
 106                 sysfsfp = fopen(temp, "r");
 107                 if (sysfsfp == NULL) {
 108                         printf("failed to open %s\n", temp);
 109                         ret = -errno;
 110                         goto error_free;
 111                 }
 112                 fscanf(sysfsfp, "%d", &test);
 113                 if (test != val) {
 114                         printf("Possible failure in int write %d to %s%s\n",
 115                                 val,
 116                                 basedir,
 117                                 filename);
 118                         ret = -1;
 119                 }
 120         }
 121 error_free:
 122         free(temp);
 123         return ret;
 124 }
 125
 126 int write_sysfs_int(char *filename, char *basedir, int val)
 127 {
 128         return _write_sysfs_int(filename, basedir, val, 0);
 129 }
 130
 131 int write_sysfs_int_and_verify(char *filename, char *basedir, int val)
 132 {
 133         return _write_sysfs_int(filename, basedir, val, 1);
 134 }
 135
 136 int _write_sysfs_string(char *filename, char *basedir, char *val, int verify)
 137 {
 138         int ret;
 139         FILE  *sysfsfp;
 140         char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
 141         if (temp == NULL) {
 142                 printf("Memory allocation failed\n");
 143                 return -ENOMEM;
 144         }
 145         sprintf(temp, "%s/%s", basedir, filename);
 146         sysfsfp = fopen(temp, "w");
 147         if (sysfsfp == NULL) {
 148                 printf("Could not open %s\n", temp);
 149                 ret = -errno;
 150                 goto error_free;
 151         }
 152         fprintf(sysfsfp, "%s", val);
 153         fclose(sysfsfp);
 154         if (verify) {
 155                 sysfsfp = fopen(temp, "r");
 156                 if (sysfsfp == NULL) {
 157                         ret = -errno;
 158                         goto error_free;
 159                 }
 160                 fscanf(sysfsfp, "%s", temp);
 161                 if (strcmp(temp, val) != 0) {
 162                         printf("Possible failure in string write of %s "
 163                                 "Should be %s "
 164                                 "writen to %s\%s\n",
 165                                 temp,
 166                                 val,
 167                                 basedir,
 168                                 filename);
 169                         ret = -1;
 170                 }
 171         }
 172 error_free:
 173         free(temp);
 174
 175         return ret;
 176 }
 177 /**
 178  * write_sysfs_string_and_verify() - string write, readback and verify
 179  * @filename: name of file to write to
 180  * @basedir: the sysfs directory in which the file is to be found
 181  * @val: the string to write
 182  **/
 183 int write_sysfs_string_and_verify(char *filename, char *basedir, char *val)
 184 {
 185         return _write_sysfs_string(filename, basedir, val, 1);
 186 }
 187
 188 int write_sysfs_string(char *filename, char *basedir, char *val)
 189 {
 190         return _write_sysfs_string(filename, basedir, val, 0);
 191 }
 192
 193 int read_sysfs_posint(char *filename, char *basedir)
 194 {
 195         int ret;
 196         FILE  *sysfsfp;
 197         char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
 198         if (temp == NULL) {
 199                 printf("Memory allocation failed");
 200                 return -ENOMEM;
 201         }
 202         sprintf(temp, "%s/%s", basedir, filename);
 203         sysfsfp = fopen(temp, "r");
 204         if (sysfsfp == NULL) {
 205                 ret = -errno;
 206                 goto error_free;
 207         }
 208         fscanf(sysfsfp, "%d\n", &ret);
 209         fclose(sysfsfp);
 210 error_free:
 211         free(temp);
 212         return ret;
 213 }
 214
 215 int read_sysfs_float(char *filename, char *basedir, float *val)
 216 {
 217         float ret = 0;
 218         FILE  *sysfsfp;
 219         char *temp = malloc(strlen(basedir) + strlen(filename) + 2);
 220         if (temp == NULL) {
 221                 printf("Memory allocation failed");
 222                 return -ENOMEM;
 223         }
 224         sprintf(temp, "%s/%s", basedir, filename);
 225         sysfsfp = fopen(temp, "r");
 226         if (sysfsfp == NULL) {
 227                 ret = -errno;
 228                 goto error_free;
 229         }
 230         fscanf(sysfsfp, "%f\n", val);
 231         fclose(sysfsfp);
 232 error_free:
 233         free(temp);
 234         return ret;
 235 }