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, 1, &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, CONSUMER); 218 if (ret < 0) 219 return ret; 220 221 fd = ret; 222 for (i = 0; i < num_lines; i++) 223 gpiotools_set_bit(&lv.mask, i); 224 ret = gpiotools_get_values(fd, &lv); 225 if (!ret) 226 for (i = 0; i < num_lines; i++) 227 values[i] = gpiotools_test_bit(lv.bits, 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, 1, &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(&config.attrs[0].mask, i); 275 gpiotools_assign_bit(&config.attrs[0].attr.values, 276 i, values[i]); 277 } 278 ret = gpiotools_request_line(device_name, lines, num_lines, 279 &config, CONSUMER); 280 if (ret < 0) 281 return ret; 282 283 return gpiotools_release_line(ret); 284 } 285