cxl/region: fix x9 interleave typo
[platform/kernel/linux-starfive.git] / tools / iio / lsiio.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Industrial I/O utilities - lsiio.c
4  *
5  * Copyright (c) 2010 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
6  */
7
8 #include <string.h>
9 #include <dirent.h>
10 #include <stdio.h>
11 #include <errno.h>
12 #include <stdint.h>
13 #include <stdlib.h>
14 #include <unistd.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <sys/dir.h>
18 #include "iio_utils.h"
19
20 static enum verbosity {
21         VERBLEVEL_DEFAULT,      /* 0 gives lspci behaviour */
22         VERBLEVEL_SENSORS,      /* 1 lists sensors */
23 } verblevel = VERBLEVEL_DEFAULT;
24
25 const char *type_device = "iio:device";
26 const char *type_trigger = "trigger";
27
28 static inline int check_prefix(const char *str, const char *prefix)
29 {
30         return strlen(str) > strlen(prefix) &&
31                strncmp(str, prefix, strlen(prefix)) == 0;
32 }
33
34 static inline int check_postfix(const char *str, const char *postfix)
35 {
36         return strlen(str) > strlen(postfix) &&
37                strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
38 }
39
40 static int dump_channels(const char *dev_dir_name)
41 {
42         DIR *dp;
43         const struct dirent *ent;
44
45         dp = opendir(dev_dir_name);
46         if (!dp)
47                 return -errno;
48
49         while (ent = readdir(dp), ent)
50                 if (check_prefix(ent->d_name, "in_") &&
51                    (check_postfix(ent->d_name, "_raw") ||
52                     check_postfix(ent->d_name, "_input")))
53                         printf("   %-10s\n", ent->d_name);
54
55         return (closedir(dp) == -1) ? -errno : 0;
56 }
57
58 static int dump_one_device(const char *dev_dir_name)
59 {
60         char name[IIO_MAX_NAME_LENGTH];
61         int dev_idx;
62         int ret;
63
64         ret = sscanf(dev_dir_name + strlen(iio_dir) + strlen(type_device), "%i",
65                      &dev_idx);
66         if (ret != 1)
67                 return -EINVAL;
68
69         ret = read_sysfs_string("name", dev_dir_name, name);
70         if (ret < 0)
71                 return ret;
72
73         printf("Device %03d: %s\n", dev_idx, name);
74
75         if (verblevel >= VERBLEVEL_SENSORS)
76                 return dump_channels(dev_dir_name);
77
78         return 0;
79 }
80
81 static int dump_one_trigger(const char *dev_dir_name)
82 {
83         char name[IIO_MAX_NAME_LENGTH];
84         int dev_idx;
85         int ret;
86
87         ret = sscanf(dev_dir_name + strlen(iio_dir) + strlen(type_trigger),
88                      "%i", &dev_idx);
89         if (ret != 1)
90                 return -EINVAL;
91
92         ret = read_sysfs_string("name", dev_dir_name, name);
93         if (ret < 0)
94                 return ret;
95
96         printf("Trigger %03d: %s\n", dev_idx, name);
97
98         return 0;
99 }
100
101 static int dump_devices(void)
102 {
103         const struct dirent *ent;
104         int ret;
105         DIR *dp;
106
107         dp = opendir(iio_dir);
108         if (!dp) {
109                 fprintf(stderr, "No industrial I/O devices available\n");
110                 return -ENODEV;
111         }
112
113         while (ent = readdir(dp), ent) {
114                 if (check_prefix(ent->d_name, type_device)) {
115                         char *dev_dir_name;
116
117                         if (asprintf(&dev_dir_name, "%s%s", iio_dir,
118                                      ent->d_name) < 0) {
119                                 ret = -ENOMEM;
120                                 goto error_close_dir;
121                         }
122
123                         ret = dump_one_device(dev_dir_name);
124                         if (ret) {
125                                 free(dev_dir_name);
126                                 goto error_close_dir;
127                         }
128
129                         free(dev_dir_name);
130                         if (verblevel >= VERBLEVEL_SENSORS)
131                                 printf("\n");
132                 }
133         }
134         rewinddir(dp);
135         while (ent = readdir(dp), ent) {
136                 if (check_prefix(ent->d_name, type_trigger)) {
137                         char *dev_dir_name;
138
139                         if (asprintf(&dev_dir_name, "%s%s", iio_dir,
140                                      ent->d_name) < 0) {
141                                 ret = -ENOMEM;
142                                 goto error_close_dir;
143                         }
144
145                         ret = dump_one_trigger(dev_dir_name);
146                         if (ret) {
147                                 free(dev_dir_name);
148                                 goto error_close_dir;
149                         }
150
151                         free(dev_dir_name);
152                 }
153         }
154
155         return (closedir(dp) == -1) ? -errno : 0;
156
157 error_close_dir:
158         if (closedir(dp) == -1)
159                 perror("dump_devices(): Failed to close directory");
160
161         return ret;
162 }
163
164 int main(int argc, char **argv)
165 {
166         int c, err = 0;
167
168         while ((c = getopt(argc, argv, "v")) != EOF) {
169                 switch (c) {
170                 case 'v':
171                         verblevel++;
172                         break;
173
174                 case '?':
175                 default:
176                         err++;
177                         break;
178                 }
179         }
180         if (err || argc > optind) {
181                 fprintf(stderr, "Usage: lsiio [options]...\n"
182                         "List industrial I/O devices\n"
183                         "  -v  Increase verbosity (may be given multiple times)\n");
184                 exit(1);
185         }
186
187         return dump_devices();
188 }