1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * GPIO mockup cdev test helper
4 *
5 * Copyright (C) 2020 Kent Gibson
6 */
7
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <signal.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <unistd.h>
16 #include <sys/ioctl.h>
17 #include <linux/gpio.h>
18
19 #define CONSUMER "gpio-mockup-cdev"
20
21 static int request_line_v2(int cfd, unsigned int offset,
22 uint64_t flags, unsigned int val)
23 {
24 struct gpio_v2_line_request req;
25 int ret;
26
27 memset(&req, 0, sizeof(req));
28 req.num_lines = 1;
29 req.offsets[0] = offset;
30 req.config.flags = flags;
31 strcpy(req.consumer, CONSUMER);
32 if (flags & GPIO_V2_LINE_FLAG_OUTPUT) {
33 req.config.num_attrs = 1;
34 req.config.attrs[0].mask = 1;
35 req.config.attrs[0].attr.id = GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES;
36 if (val)
37 req.config.attrs[0].attr.values = 1;
38 }
39 ret = ioctl(cfd, GPIO_V2_GET_LINE_IOCTL, &req);
40 if (ret == -1)
41 return -errno;
42 return req.fd;
43 }
44
45
46 static int get_value_v2(int lfd)
47 {
48 struct gpio_v2_line_values vals;
49 int ret;
50
51 memset(&vals, 0, sizeof(vals));
52 vals.mask = 1;
53 ret = ioctl(lfd, GPIO_V2_LINE_GET_VALUES_IOCTL, &vals);
54 if (ret == -1)
55 return -errno;
56 return vals.bits & 0x1;
57 }
58
59 static int request_line_v1(int cfd, unsigned int offset,
60 uint32_t flags, unsigned int val)
61 {
62 struct gpiohandle_request req;
63 int ret;
64
65 memset(&req, 0, sizeof(req));
66 req.lines = 1;
67 req.lineoffsets[0] = offset;
68 req.flags = flags;
69 strcpy(req.consumer_label, CONSUMER);
70 if (flags & GPIOHANDLE_REQUEST_OUTPUT)
71 req.default_values[0] = val;
72
73 ret = ioctl(cfd, GPIO_GET_LINEHANDLE_IOCTL, &req);
74 if (ret == -1)
75 return -errno;
76 return req.fd;
77 }
78
79 static int get_value_v1(int lfd)
80 {
81 struct gpiohandle_data vals;
82 int ret;
83
84 memset(&vals, 0, sizeof(vals));
85 ret = ioctl(lfd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &vals);
86 if (ret == -1)
87 return -errno;
88 return vals.values[0];
89 }
90
91 static void usage(char *prog)
92 {
93 printf("Usage: %s [-l] [-b <bias>] [-s <value>] [-u <uAPI>] <gpiochip> <offset>\n", prog);
94 printf(" -b: set line bias to one of pull-down, pull-up, disabled\n");
95 printf(" (default is to leave bias unchanged):\n");
96 printf(" -l: set line active low (default is active high)\n");
97 printf(" -s: set line value (default is to get line value)\n");
98 printf(" -u: uAPI version to use (default is 2)\n");
99 exit(-1);
100 }
101
102 static int wait_signal(void)
103 {
104 int sig;
105 sigset_t wset;
106
107 sigemptyset(&wset);
108 sigaddset(&wset, SIGHUP);
109 sigaddset(&wset, SIGINT);
110 sigaddset(&wset, SIGTERM);
111 sigwait(&wset, &sig);
112
113 return sig;
114 }
115
116 int main(int argc, char *argv[])
117 {
118 char *chip;
119 int opt, ret, cfd, lfd;
120 unsigned int offset, val = 0, abiv;
121 uint32_t flags_v1;
122 uint64_t flags_v2;
123
124 abiv = 2;
125 ret = 0;
126 flags_v1 = GPIOHANDLE_REQUEST_INPUT;
127 flags_v2 = GPIO_V2_LINE_FLAG_INPUT;
128
129 while ((opt = getopt(argc, argv, "lb:s:u:")) != -1) {
130 switch (opt) {
131 case 'l':
132 flags_v1 |= GPIOHANDLE_REQUEST_ACTIVE_LOW;
133 flags_v2 |= GPIO_V2_LINE_FLAG_ACTIVE_LOW;
134 break;
135 case 'b':
136 if (strcmp("pull-up", optarg) == 0) {
137 flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_UP;
138 flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_PULL_UP;
139 } else if (strcmp("pull-down", optarg) == 0) {
140 flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_DOWN;
141 flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN;
142 } else if (strcmp("disabled", optarg) == 0) {
143 flags_v1 |= GPIOHANDLE_REQUEST_BIAS_DISABLE;
144 flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_DISABLED;
145 }
146 break;
147 case 's':
148 val = atoi(optarg);
149 flags_v1 &= ~GPIOHANDLE_REQUEST_INPUT;
150 flags_v1 |= GPIOHANDLE_REQUEST_OUTPUT;
151 flags_v2 &= ~GPIO_V2_LINE_FLAG_INPUT;
152 flags_v2 |= GPIO_V2_LINE_FLAG_OUTPUT;
153 break;
154 case 'u':
155 abiv = atoi(optarg);
156 break;
157 default:
158 usage(argv[0]);
159 }
160 }
161
162 if (argc < optind + 2)
163 usage(argv[0]);
164
165 chip = argv[optind];
166 offset = atoi(argv[optind + 1]);
167
168 cfd = open(chip, 0);
169 if (cfd == -1) {
170 fprintf(stderr, "Failed to open %s: %s\n", chip, strerror(errno));
171 return -errno;
172 }
173
174 if (abiv == 1)
175 lfd = request_line_v1(cfd, offset, flags_v1, val);
176 else
177 lfd = request_line_v2(cfd, offset, flags_v2, val);
178
179 close(cfd);
180
181 if (lfd < 0) {
182 fprintf(stderr, "Failed to request %s:%d: %s\n", chip, offset, strerror(-lfd));
183 return lfd;
184 }
185
186 if (flags_v2 & GPIO_V2_LINE_FLAG_OUTPUT) {
187 wait_signal();
188 } else {
189 if (abiv == 1)
190 ret = get_value_v1(lfd);
191 else
192 ret = get_value_v2(lfd);
193 }
194
195 close(lfd);
196
197 return ret;
198 }
199
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.