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