tools/gpio/gpio-utils.c

   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, %s\n",
  80                         chrdev_name, strerror(errno));
  81                 goto exit_close_error;
  82         }
  83
  84         for (i = 0; i < nlines; i++)
  85                 req.lineoffsets[i] = lines[i];
  86
  87         req.flags = flag;
  88         strcpy(req.consumer_label, consumer_label);
  89         req.lines = nlines;
  90         if (flag & GPIOHANDLE_REQUEST_OUTPUT)
  91                 memcpy(req.default_values, data, sizeof(req.default_values));
  92
  93         ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);
  94         if (ret == -1) {
  95                 ret = -errno;
  96                 fprintf(stderr, "Failed to issue %s (%d), %s\n",
  97                         "GPIO_GET_LINEHANDLE_IOCTL", ret, strerror(errno));
  98         }
  99
 100 exit_close_error:
 101         if (close(fd) == -1)
 102                 perror("Failed to close GPIO character device file");
 103         free(chrdev_name);
 104         return ret < 0 ? ret : req.fd;
 105 }
 106 /**
 107  * gpiotools_set_values(): Set the value of gpio(s)
 108  * @fd:                 The fd returned by
 109  *                      gpiotools_request_linehandle().
 110  * @data:               The array of values want to set.
 111  *
 112  * Return:              On success return 0;
 113  *                      On failure return the errno.
 114  */
 115 int gpiotools_set_values(const int fd, struct gpiohandle_data *data)
 116 {
 117         int ret;
 118
 119         ret = ioctl(fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, data);
 120         if (ret == -1) {
 121                 ret = -errno;
 122                 fprintf(stderr, "Failed to issue %s (%d), %s\n",
 123                         "GPIOHANDLE_SET_LINE_VALUES_IOCTL", ret,
 124                         strerror(errno));
 125         }
 126
 127         return ret;
 128 }
 129
 130 /**
 131  * gpiotools_get_values(): Get the value of gpio(s)
 132  * @fd:                 The fd returned by
 133  *                      gpiotools_request_linehandle().
 134  * @data:               The array of values get from hardware.
 135  *
 136  * Return:              On success return 0;
 137  *                      On failure return the errno.
 138  */
 139 int gpiotools_get_values(const int fd, struct gpiohandle_data *data)
 140 {
 141         int ret;
 142
 143         ret = ioctl(fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, data);
 144         if (ret == -1) {
 145                 ret = -errno;
 146                 fprintf(stderr, "Failed to issue %s (%d), %s\n",
 147                         "GPIOHANDLE_GET_LINE_VALUES_IOCTL", ret,
 148                         strerror(errno));
 149         }
 150
 151         return ret;
 152 }
 153
 154 /**
 155  * gpiotools_release_linehandle(): Release the line(s) of gpiochip
 156  * @fd:                 The fd returned by
 157  *                      gpiotools_request_linehandle().
 158  *
 159  * Return:              On success return 0;
 160  *                      On failure return the errno.
 161  */
 162 int gpiotools_release_linehandle(const int fd)
 163 {
 164         int ret;
 165
 166         ret = close(fd);
 167         if (ret == -1) {
 168                 perror("Failed to close GPIO LINEHANDLE device file");
 169                 ret = -errno;
 170         }
 171
 172         return ret;
 173 }
 174
 175 /**
 176  * gpiotools_get(): Get value from specific line
 177  * @device_name:        The name of gpiochip without prefix "/dev/",
 178  *                      such as "gpiochip0"
 179  * @line:               number of line, such as 2.
 180  *
 181  * Return:              On success return 0;
 182  *                      On failure return the errno.
 183  */
 184 int gpiotools_get(const char *device_name, unsigned int line)
 185 {
 186         struct gpiohandle_data data;
 187         unsigned int lines[] = {line};
 188
 189         gpiotools_gets(device_name, lines, 1, &data);
 190         return data.values[0];
 191 }
 192
 193
 194 /**
 195  * gpiotools_gets(): Get values from specific lines.
 196  * @device_name:        The name of gpiochip without prefix "/dev/",
 197  *                      such as "gpiochip0".
 198  * @lines:              An array desired lines, specified by offset
 199  *                      index for the associated GPIO device.
 200  * @nline:              The number of lines to request.
 201  * @data:               The array of values get from gpiochip.
 202  *
 203  * Return:              On success return 0;
 204  *                      On failure return the errno.
 205  */
 206 int gpiotools_gets(const char *device_name, unsigned int *lines,
 207                    unsigned int nlines, struct gpiohandle_data *data)
 208 {
 209         int fd;
 210         int ret;
 211         int ret_close;
 212
 213         ret = gpiotools_request_linehandle(device_name, lines, nlines,
 214                                            GPIOHANDLE_REQUEST_INPUT, data,
 215                                            COMSUMER);
 216         if (ret < 0)
 217                 return ret;
 218
 219         fd = ret;
 220         ret = gpiotools_get_values(fd, data);
 221         ret_close = gpiotools_release_linehandle(fd);
 222         return ret < 0 ? ret : ret_close;
 223 }
 224
 225 /**
 226  * gpiotools_set(): Set value to specific line
 227  * @device_name:        The name of gpiochip without prefix "/dev/",
 228  *                      such as "gpiochip0"
 229  * @line:               number of line, such as 2.
 230  * @value:              The value of gpio, must be 0(low) or 1(high).
 231  *
 232  * Return:              On success return 0;
 233  *                      On failure return the errno.
 234  */
 235 int gpiotools_set(const char *device_name, unsigned int line,
 236                   unsigned int value)
 237 {
 238         struct gpiohandle_data data;
 239         unsigned int lines[] = {line};
 240
 241         data.values[0] = value;
 242         return gpiotools_sets(device_name, lines, 1, &data);
 243 }
 244
 245 /**
 246  * gpiotools_sets(): Set values to specific lines.
 247  * @device_name:        The name of gpiochip without prefix "/dev/",
 248  *                      such as "gpiochip0".
 249  * @lines:              An array desired lines, specified by offset
 250  *                      index for the associated GPIO device.
 251  * @nline:              The number of lines to request.
 252  * @data:               The array of values set to gpiochip, must be
 253  *                      0(low) or 1(high).
 254  *
 255  * Return:              On success return 0;
 256  *                      On failure return the errno.
 257  */
 258 int gpiotools_sets(const char *device_name, unsigned int *lines,
 259                    unsigned int nlines, struct gpiohandle_data *data)
 260 {
 261         int ret;
 262
 263         ret = gpiotools_request_linehandle(device_name, lines, nlines,
 264                                            GPIOHANDLE_REQUEST_OUTPUT, data,
 265                                            COMSUMER);
 266         if (ret < 0)
 267                 return ret;
 268
 269         return gpiotools_release_linehandle(ret);
 270 }