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