1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * GPIO tools - helpers library for the GPIO tools |
4 | * |
5 | * Copyright (C) 2015 Linus Walleij |
6 | * Copyright (C) 2016 Bamvor Jian Zhang |
7 | */ |
8 | |
9 | #include <unistd.h> |
10 | #include <stdlib.h> |
11 | #include <stdio.h> |
12 | #include <errno.h> |
13 | #include <string.h> |
14 | #include <fcntl.h> |
15 | #include <getopt.h> |
16 | #include <sys/ioctl.h> |
17 | #include <linux/gpio.h> |
18 | #include "gpio-utils.h" |
19 | |
20 | #define CONSUMER "gpio-utils" |
21 | |
22 | /** |
23 | * DOC: Operation of gpio |
24 | * |
25 | * Provide the api of gpiochip for chardev interface. There are two |
26 | * types of api. The first one provide as same function as each |
27 | * ioctl, including request and release for lines of gpio, read/write |
28 | * the value of gpio. If the user want to do lots of read and write of |
29 | * lines of gpio, user should use this type of api. |
30 | * |
31 | * The second one provide the easy to use api for user. Each of the |
32 | * following api will request gpio lines, do the operation and then |
33 | * release these lines. |
34 | */ |
35 | |
36 | /** |
37 | * gpiotools_request_line() - request gpio lines in a gpiochip |
38 | * @device_name: The name of gpiochip without prefix "/dev/", |
39 | * such as "gpiochip0" |
40 | * @lines: An array desired lines, specified by offset |
41 | * index for the associated GPIO device. |
42 | * @num_lines: The number of lines to request. |
43 | * @config: The new config for requested gpio. Reference |
44 | * "linux/gpio.h" for config details. |
45 | * @consumer: The name of consumer, such as "sysfs", |
46 | * "powerkey". This is useful for other users to |
47 | * know who is using. |
48 | * |
49 | * Request gpio lines through the ioctl provided by chardev. User |
50 | * could call gpiotools_set_values() and gpiotools_get_values() to |
51 | * read and write respectively through the returned fd. Call |
52 | * gpiotools_release_line() to release these lines after that. |
53 | * |
54 | * Return: On success return the fd; |
55 | * On failure return the errno. |
56 | */ |
57 | int gpiotools_request_line(const char *device_name, unsigned int *lines, |
58 | unsigned int num_lines, |
59 | struct gpio_v2_line_config *config, |
60 | const char *consumer) |
61 | { |
62 | struct gpio_v2_line_request req; |
63 | char *chrdev_name; |
64 | int fd; |
65 | int i; |
66 | int ret; |
67 | |
68 | ret = asprintf(&chrdev_name, "/dev/%s" , device_name); |
69 | if (ret < 0) |
70 | return -ENOMEM; |
71 | |
72 | fd = open(chrdev_name, 0); |
73 | if (fd == -1) { |
74 | ret = -errno; |
75 | fprintf(stderr, "Failed to open %s, %s\n" , |
76 | chrdev_name, strerror(errno)); |
77 | goto exit_free_name; |
78 | } |
79 | |
80 | memset(&req, 0, sizeof(req)); |
81 | for (i = 0; i < num_lines; i++) |
82 | req.offsets[i] = lines[i]; |
83 | |
84 | req.config = *config; |
85 | strcpy(req.consumer, consumer); |
86 | req.num_lines = num_lines; |
87 | |
88 | ret = ioctl(fd, GPIO_V2_GET_LINE_IOCTL, &req); |
89 | if (ret == -1) { |
90 | ret = -errno; |
91 | fprintf(stderr, "Failed to issue %s (%d), %s\n" , |
92 | "GPIO_GET_LINE_IOCTL" , ret, strerror(errno)); |
93 | } |
94 | |
95 | if (close(fd) == -1) |
96 | perror("Failed to close GPIO character device file" ); |
97 | exit_free_name: |
98 | free(chrdev_name); |
99 | return ret < 0 ? ret : req.fd; |
100 | } |
101 | |
102 | /** |
103 | * gpiotools_set_values() - Set the value of gpio(s) |
104 | * @fd: The fd returned by |
105 | * gpiotools_request_line(). |
106 | * @values: The array of values want to set. |
107 | * |
108 | * Return: On success return 0; |
109 | * On failure return the errno. |
110 | */ |
111 | int gpiotools_set_values(const int fd, struct gpio_v2_line_values *values) |
112 | { |
113 | int ret; |
114 | |
115 | ret = ioctl(fd, GPIO_V2_LINE_SET_VALUES_IOCTL, values); |
116 | if (ret == -1) { |
117 | ret = -errno; |
118 | fprintf(stderr, "Failed to issue %s (%d), %s\n" , |
119 | "GPIOHANDLE_SET_LINE_VALUES_IOCTL" , ret, |
120 | strerror(errno)); |
121 | } |
122 | |
123 | return ret; |
124 | } |
125 | |
126 | /** |
127 | * gpiotools_get_values() - Get the value of gpio(s) |
128 | * @fd: The fd returned by |
129 | * gpiotools_request_line(). |
130 | * @values: The array of values get from hardware. |
131 | * |
132 | * Return: On success return 0; |
133 | * On failure return the errno. |
134 | */ |
135 | int gpiotools_get_values(const int fd, struct gpio_v2_line_values *values) |
136 | { |
137 | int ret; |
138 | |
139 | ret = ioctl(fd, GPIO_V2_LINE_GET_VALUES_IOCTL, values); |
140 | if (ret == -1) { |
141 | ret = -errno; |
142 | fprintf(stderr, "Failed to issue %s (%d), %s\n" , |
143 | "GPIOHANDLE_GET_LINE_VALUES_IOCTL" , ret, |
144 | strerror(errno)); |
145 | } |
146 | |
147 | return ret; |
148 | } |
149 | |
150 | /** |
151 | * gpiotools_release_line() - Release the line(s) of gpiochip |
152 | * @fd: The fd returned by |
153 | * gpiotools_request_line(). |
154 | * |
155 | * Return: On success return 0; |
156 | * On failure return the errno. |
157 | */ |
158 | int gpiotools_release_line(const int fd) |
159 | { |
160 | int ret; |
161 | |
162 | ret = close(fd); |
163 | if (ret == -1) { |
164 | perror("Failed to close GPIO LINE device file" ); |
165 | ret = -errno; |
166 | } |
167 | |
168 | return ret; |
169 | } |
170 | |
171 | /** |
172 | * gpiotools_get() - Get value from specific line |
173 | * @device_name: The name of gpiochip without prefix "/dev/", |
174 | * such as "gpiochip0" |
175 | * @line: number of line, such as 2. |
176 | * |
177 | * Return: On success return 0; |
178 | * On failure return the errno. |
179 | */ |
180 | int gpiotools_get(const char *device_name, unsigned int line) |
181 | { |
182 | int ret; |
183 | unsigned int value; |
184 | unsigned int lines[] = {line}; |
185 | |
186 | ret = gpiotools_gets(device_name, lines, num_lines: 1, values: &value); |
187 | if (ret) |
188 | return ret; |
189 | return value; |
190 | } |
191 | |
192 | |
193 | /** |
194 | * gpiotools_gets() - Get values from specific lines. |
195 | * @device_name: The name of gpiochip without prefix "/dev/", |
196 | * such as "gpiochip0". |
197 | * @lines: An array desired lines, specified by offset |
198 | * index for the associated GPIO device. |
199 | * @num_lines: The number of lines to request. |
200 | * @values: The array of values get from gpiochip. |
201 | * |
202 | * Return: On success return 0; |
203 | * On failure return the errno. |
204 | */ |
205 | int gpiotools_gets(const char *device_name, unsigned int *lines, |
206 | unsigned int num_lines, unsigned int *values) |
207 | { |
208 | int fd, i; |
209 | int ret; |
210 | int ret_close; |
211 | struct gpio_v2_line_config config; |
212 | struct gpio_v2_line_values lv; |
213 | |
214 | memset(&config, 0, sizeof(config)); |
215 | config.flags = GPIO_V2_LINE_FLAG_INPUT; |
216 | ret = gpiotools_request_line(device_name, lines, num_lines, |
217 | config: &config, CONSUMER); |
218 | if (ret < 0) |
219 | return ret; |
220 | |
221 | fd = ret; |
222 | for (i = 0; i < num_lines; i++) |
223 | gpiotools_set_bit(b: &lv.mask, n: i); |
224 | ret = gpiotools_get_values(fd, values: &lv); |
225 | if (!ret) |
226 | for (i = 0; i < num_lines; i++) |
227 | values[i] = gpiotools_test_bit(b: lv.bits, n: i); |
228 | ret_close = gpiotools_release_line(fd); |
229 | return ret < 0 ? ret : ret_close; |
230 | } |
231 | |
232 | /** |
233 | * gpiotools_set() - Set value to specific line |
234 | * @device_name: The name of gpiochip without prefix "/dev/", |
235 | * such as "gpiochip0" |
236 | * @line: number of line, such as 2. |
237 | * @value: The value of gpio, must be 0(low) or 1(high). |
238 | * |
239 | * Return: On success return 0; |
240 | * On failure return the errno. |
241 | */ |
242 | int gpiotools_set(const char *device_name, unsigned int line, |
243 | unsigned int value) |
244 | { |
245 | unsigned int lines[] = {line}; |
246 | |
247 | return gpiotools_sets(device_name, lines, num_lines: 1, values: &value); |
248 | } |
249 | |
250 | /** |
251 | * gpiotools_sets() - Set values to specific lines. |
252 | * @device_name: The name of gpiochip without prefix "/dev/", |
253 | * such as "gpiochip0". |
254 | * @lines: An array desired lines, specified by offset |
255 | * index for the associated GPIO device. |
256 | * @num_lines: The number of lines to request. |
257 | * @values: The array of values set to gpiochip, must be |
258 | * 0(low) or 1(high). |
259 | * |
260 | * Return: On success return 0; |
261 | * On failure return the errno. |
262 | */ |
263 | int gpiotools_sets(const char *device_name, unsigned int *lines, |
264 | unsigned int num_lines, unsigned int *values) |
265 | { |
266 | int ret, i; |
267 | struct gpio_v2_line_config config; |
268 | |
269 | memset(&config, 0, sizeof(config)); |
270 | config.flags = GPIO_V2_LINE_FLAG_OUTPUT; |
271 | config.num_attrs = 1; |
272 | config.attrs[0].attr.id = GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES; |
273 | for (i = 0; i < num_lines; i++) { |
274 | gpiotools_set_bit(b: &config.attrs[0].mask, n: i); |
275 | gpiotools_assign_bit(b: &config.attrs[0].attr.values, |
276 | n: i, value: values[i]); |
277 | } |
278 | ret = gpiotools_request_line(device_name, lines, num_lines, |
279 | config: &config, CONSUMER); |
280 | if (ret < 0) |
281 | return ret; |
282 | |
283 | return gpiotools_release_line(fd: ret); |
284 | } |
285 | |